Abstract Rewriting Challenge (Poliziotti)


27

Questa è una sfida da qualche modo simile al . Questo è il filo della polizia; il thread dei ladri è qui.

Cops

Il tuo compito è definire un sistema di riscrittura astratto in cui è difficile determinare la raggiungibilità di una parola da un'altra. Preparerai le seguenti cose:

  1. Un insieme di simboli, chiamato alfabeto. (Puoi usare qualsiasi carattere Unicode per questi, ma per favore non usare spazi bianchi o simboli che sono difficili da distinguere l'uno dall'altro.)

  2. Una stringa di origine composta da simboli dell'alfabeto.

  3. Una stringa di destinazione composta da simboli dell'alfabeto.

  4. Un insieme di regole di riscrittura usando i caratteri dell'alfabeto. (Vedi sotto per la definizione di una regola di riscrittura.)

  5. Una prova che mostra se la stringa di origine può essere convertita nella stringa di destinazione mediante l'applicazione successiva delle regole di riscrittura. Questa dimostrazione potrebbe consistere in una sequenza effettiva di passaggi di riscrittura o in una prova matematica che tale sequenza deve esistere o in una prova matematica che tale sequenza non esiste.

Pubblicherai i primi quattro di questi, mantenendo segreta la prova; i ladri proveranno a decifrare la tua risposta fornendo la propria prova che la tua stringa target può o non può essere raggiunta dalla tua stringa sorgente. Se l'invio non viene infranto entro due settimane , è possibile contrassegnarlo come sicuro e modificarlo nella prova.

Le iscrizioni verranno classificate in base al numero di caratteri nelle regole di riscrittura e nelle stringhe di origine e di destinazione, come indicato di seguito. Il vincitore sarà l'invio non crackato con il punteggio più basso.

Che cos'è una regola di riscrittura?

Una regola di riscrittura è semplicemente una coppia di stringhe nel tuo alfabeto. (Ognuna di queste stringhe può essere vuota.) L'applicazione di una regola di riscrittura consiste nel trovare una sottostringa uguale alla prima stringa nella coppia e sostituirla con la seconda.

Un esempio dovrebbe chiarire questo:

Supponiamo che l'alfabeto sia A, Be C; la stringa di origine è " A"; la stringa di destinazione è " C" e le regole di riscrittura sono

A:B
B:BB
B:A
AA:C

quindi la stringa di destinazione è raggiungibile nel modo seguente:

A
B   (using rule 1)
BB  (using rule 2)
AB  (using rule 3)
AA  (using rule 3)
C   (using rule 4)

punteggio

Il tuo punteggio sarà

  • la lunghezza della stringa di origine,
  • più la lunghezza della stringa target,
  • oltre alla lunghezza di tutte le stringhe incluse nelle regole di riscrittura,
  • più un punto in più per ogni regola di riscrittura.

Se scrivi le tue regole di riscrittura con un separatore di due punti come sopra, questa è solo la lunghezza totale di tutte le regole di riscrittura (incluso il separatore), più le lunghezze delle stringhe sorgente e target. Un punteggio più basso è migliore. Il numero di caratteri distinti nel tuo alfabeto verrà utilizzato per rompere i legami, con un minor numero di migliori.

generosità

Mi piacerebbe vedere le risposte che vanno davvero per i punteggi bassi. Assegnerò 200 rappresentanti alla prima risposta che segna meno di 100 punti in questa sfida e non si spezza.


3
Bah, non abbastanza espressivo per il puzzle MU .
Neil

1
@Neil tecnicamente sono espressivi quanto le macchine di Turing - potresti creare una versione del puzzle MU, ma per implementare la Mx -> Mxxregola avresti bisogno di un sacco di simboli extra e regole di transizione , quindi sarebbe molto più complicato di quello di Hofstadter originale.
Nathaniel

Risposte:


9

326 punti - Cracking di jimmy23013

Il livello è Picokosmos # 13 di Aymeric du Peloux (con una banale modifica). Ho cercato di trovare un livello di buon gusto che potesse essere implementato con "scatole" e "muri" che fossero lo stesso personaggio. Per questo livello è stato possibile rendere il punto di strozzatura centrale largo due colonne anziché una.

Le regole / stringhe iniziali / target potrebbero essere giocate a golf un po 'di più, ma questo è solo per divertimento.

Stringa iniziale:

___##___####_____##_#_#_##_#_!####______##_#####__####_#_######__###__

Stringa di destinazione:

___##___####_____##_#_#_##_#_#####____!__#_#####__####_#_######__###__

Regole:

_wW:!
_<:<_
Vv_:!
V_:_V
R:>>>>>>>>>>>>>
V#:#V
#w<:w#
>v_:_v
_wX:#
_!:!_
!:wLW_
L:<<<<<<<<<<<<<
#W:W#
!#_:_!#
_w<:w_
#<:<#
!:_VRv
>v#:#v
Uv_:#
_W:W_
_X:X_
>#:#>
#X:X#
U_:_U
Vv#:!URv
#wW:wLX!
>_:_>
!_:_!
_#!:#!_
U#:#U


8

171 punti, rotto da HyperNeutrino

Fonte: YAAAT

Bersaglio: VW626206555675126212043640270477001760465526277571600601

Regole:

T:AAAAAT
T:BBU
U:BU
U:ZW
AB:BCA
CB:BC
AZ:Z
CZ:ZC
YB:Y
YZ:V
V:VD
DCC:CD
DCW:W+
DW:W_
___:0
__+:1
_+_:2
_++:3
+__:4
+_+:5
++_:6
+++:7

Solo qualcosa di ovvio da fare. La sequenza effettiva di passaggi di riscrittura probabilmente non si adatta a una risposta SE.


Devo aver vacillato da qualche parte perché posso solo arrivare a VWxdove xè formato da qualsiasi stringa binaria di _(0) e +(1) che valuta in 10*n+6(compreso il primo _; n= intero non negativo) ma il xdato ( 626...601) è formato da binario che valuta a 10*n+3(per un grande n).
Jonathan Allan,

Cose come questa sono risolvibili con la pura logica?
VortexYT


@HyperNeutrino Drat, speravo che il tuo crack si fosse esposto dove mi ero imbattuto.
Jonathan Allan,


4

139 punti (sicurezza)

Volevo che questa risposta fosse decifrata, e user202729 sostanzialmente l'ha risolta nei commenti, ma nessuno ha pubblicato una risposta nel thread dei ladri, quindi la segnerò come "sicura" e includendo la mia prova di seguito.

(Queste cose sono evidentemente molto più facili da realizzare di quanto non siano da decifrare. Nessuno ha ancora tentato di ottenere un punteggio davvero basso, e ci potrebbe essere più divertimento a quel punto, se questa sfida dovesse decollare. )


Ecco un'auto risposta. È potenzialmente molto difficile, ma dovrebbe essere facile se capisci da dove proviene.

alfabeto: ABCDEⒶⒷⒸⒹⒺⒻ⬛⚪️️🎂←→

fonte: ←A→

bersaglio: ←🎂→

Regole: (gli spazi bianchi non sono significativi)

← : ←⬛
→ : ⬛→
A⬛ : ⚪B
A⚪ : ⚪Ⓑ
⬛Ⓐ : E⚪
⚪Ⓐ : Ⓔ⚪
B⬛ : ⚪C
B⚪ : ⚪Ⓒ
Ⓑ⬛ : 🎂
Ⓑ⚪ : ⚪Ⓕ
⬛C : D⚪
⚪C : Ⓓ⚪
Ⓒ⬛ : ⬛B
Ⓒ⚪ : ⬛Ⓑ
D⬛ : ⚪E
D⚪ : ⚪Ⓔ
⬛Ⓓ : C⬛
⚪Ⓓ : Ⓒ⬛
⬛E : A⚪
⚪E : Ⓐ⚪
Ⓔ⬛ : ⬛D
Ⓔ⚪ : ⬛Ⓓ
Ⓕ⬛ : ⚪C
Ⓕ⚪ : ⚪Ⓒ
⬛🎂 : 🎂
⚪🎂 : 🎂
🎂⬛ : 🎂
🎂⚪ : 🎂

Ecco una versione ASCII , nel caso in cui Unicode non venga visualizzato bene per tutti.


Prova

Ciò equivale all'attuale miglior concorrente per un castoro occupato a sei stati . Un castoro indaffarato è una macchina di Turing che si ferma dopo molto tempo. Per questo motivo, la stringa di origine ←A→può effettivamente essere trasformata nella stringa di destinazione ←🎂→, ma solo dopo più di 7*10^36534passaggi, che richiederebbero molto più tempo dell'età dell'universo per qualsiasi implementazione fisica.

Il nastro della macchina Turing è rappresentato dai simboli (0) e (1). Le regole

← : ←⬛
→ : ⬛→

significa che le estremità del nastro possono sempre essere estese con più zeri. Se il capo della macchina di Turing si avvicina mai a un'estremità del nastro, possiamo semplicemente applicare una di queste regole, che ci consente di fingere che il nastro sia infinito e inizia riempito con tutti gli zeri. (I simboli e non vengono mai creati o distrutti, quindi sono sempre alle estremità del nastro.)

La testa della macchina di Turing è rappresentata con i simboli ABCDEⒶⒷⒸⒹⒺⒻe 🎂. Asignifica che la testa è nello stato Ae il simbolo sotto la testa è un (0), mentre Ⓐ significa che è nello stato Ae il simbolo sotto di essa è un (1). Questo è continuato per gli altri stati, con la lettera cerchiata che rappresenta un 1 sotto la testa e la versione non cerchiata che rappresenta uno 0. (Non esiste alcun simbolo Fperché capita che la testa non finisca mai nello stato Fcon un 1 sotto di essa).

Lo stato 🎂è lo stato di arresto. Ha le regole speciali

⬛🎂 : 🎂
⚪🎂 : 🎂
🎂⬛ : 🎂
🎂⚪ : 🎂

Se lo stato di arresto viene mai raggiunto, possiamo applicare ripetutamente queste regole per "risucchiare" tutto il nastro (inclusi eventuali zeri extra che sono sorti dall'estensione del nastro più del necessario), lasciandoci nello stato ←🎂→. Pertanto, il problema della raggiungibilità si riduce a se lo stato 🎂sarà mai raggiunto.

Le restanti regole sono le regole di transizione per la macchina Turing. Ad esempio, le regole

A⬛ : ⚪B
A⚪ : ⚪Ⓑ

può essere letto come "se la macchina è nello stato A e c'è uno zero sotto la testa, quindi scrivere un 1, passare allo stato B e spostarsi a destra". Lo spostamento a destra richiede due regole, perché la cella a nastro a destra potrebbe contenere a , nel qual caso la macchina dovrebbe andare in stato B, o la cella potrebbe contenere a , nel qual caso dovrebbe andare in stato , poiché c'è un sottostante.

Allo stesso modo,

⬛Ⓓ : C⬛
⚪Ⓓ : Ⓒ⬛

significa "se la macchina è nello stato D e c'è un 1 sotto la testa, quindi scrivere uno 0, passare allo stato C e spostarsi a sinistra."

La macchina di Turing utilizzata è stata scoperta da Pavel Kropitz nel 2010. Sebbene sia spesso menzionata nel contesto di castori indaffarati, la sua tabella di transizione effettiva è un po 'complicata da rintracciare, ma può essere trovata ad esempio qui . Può essere scritto come

    0   1

A   1RB 1LE
B   1RC 1RF
C   1LD 0RB
D   1RE 0LC
E   1LA 0RD
F   1RH 1RC

che può essere letto come "se la macchina è nello stato A e c'è uno zero sotto la testa, quindi scrivere un 1, passare allo stato B e spostarsi a destra", e così via. Dovrebbe essere semplice, se laborioso, verificare che ogni voce di questa tabella corrisponda a una coppia di regole come descritto sopra.

L'unica eccezione è la regola 1RHche si verifica quando la macchina si trova nello stato F su uno 0, perché sembrava abbastanza inutile far scrivere a 1 la macchina e spostarsi a destra quando poteva fermarsi immediatamente non appena entrava nello stato F oltre uno 0. Quindi ho cambiato la regola che sarebbe stata

Ⓑ⬛ : ⚪F

in

Ⓑ⬛ : 🎂

Questo è il motivo per cui non c'è alcun simbolo Fnell'alfabeto. (Ci sono alcuni altri "golf" che avrei potuto fare, ma non volevo oscurarlo troppo.)

È praticamente tutto. La stringa di destinazione è raggiungibile dalla stringa di origine, ma solo dopo un numero ridicolo di passaggi.

Un altro fatto divertente: se avessi usato

←A⚪⚪→

come punto di partenza invece, non ci vorranno 7*10^36534passi per fermarsi, ma 10^10^10^10^18705352passi, che è davvero un numero molto grande.


1
Sembra un'implementazione di una turing machine
NieDzejkob

1
Penso che questa sia la macchina di Turing "attuale contendente a 6 stati e 2 simboli" elencata qui . Ora qualcuno deve solo dimostrare di essere equivalente.
user202729


1
@ user202729 Perché non pubblicare una risposta?
jimmy23013,


3

287 punti, sicuro

Fonte: YAAT

Bersaglio:

VW644507203420630255035757474755142053542246325217734264734527745236024300376212053464720055350477167345032015327021403167165534313137253235506613164473217702550435776242713

Regole:

T:AAAAAT
T:BBU
U:BU
U:ZW
AB:BCA
CB:BC
AZ:Z
CZ:ZC
YB:Y
YZ:V
V:VD
DCC:CD
DCW:W+
DW:W_
___:0
__+:1
_+_:2
_++:3
+__:4
+_+:5
++_:6
+++:7

Ho scoperto che openssl è molto più facile da usare rispetto a gpg per questo scopo.


Vedi il crack di HyperNeutrino alla versione più debole. In questo caso, il numero di Cs è:

22030661124527021657244569669713986649562044939414344827127551659400215941242670121250289039666163853124410625741840610262419007778597078437731811349579211

E i fattori primi sono:

220040395270643587721928041668579651570457474080109642875632513424514300377757
100120985046540745657156603717368093083538096517411033964934953688222272684423

Il primo numero mod 5 = 2, quindi è possibile ottenere la stringa finale.



Supponendo che si tratti di un semiprime casuale a 512 bit, i PC attuali impiegheranno settimane o mesi per
tenerne conto

Adesso è al sicuro.
user202729

2

402 punti

Alfabeto: abcdefghijklmnopqrstu
Fonte: abcdoi
Target: ioabcdnnnnnnnnnnnnnnnnnn
Riscrivi regole:

ab: ba
ba: ab
ac: ca
ca: ac
aggiungere un
da: annuncio
BC: cb
CB: bc
BD: db
db: bd
cd: dc
dc: cd
naan
nb: bn
nc: cn
ND: dn
nm: mn
NJ: jn
Aoi: EAG
Boi: EBG
coi: ecg
doi: edg
AE: ha
essere: hb
ce: hc
de: hd
IOA: kam
IOB: KBM
ioc: KCM
iod: kdm
ma: aj
mb: BJ
mc: cj
md: dj
dg: rdnnnnnnnnnn
CG: qcnnnnn
bg: pbnn
ag: ventilatore
cr: fc
BR: fb
ar: fa
bq: fb
aq: fa
ap: fa
ER: io
eq: io
ep: io
ef: io
hf: io
kd: dunnnnnnnnnn
kc: ctnnnnn
kb: bsnn
ka: aln
uc: cl
ub: bl
ua: al
tb: bl
ta: al
sa: al
um: oi
tm: OI
sm: OI
lm: OI
LJ: OI
n

L'ultima regola ti consente di creare tutti gli ns di cui hai bisogno.

Brutto come sembra, in realtà è abbastanza carino, in un modo o nell'altro ...


* In aoi:eogsi eogsuppone che sia eag?
Kritixi Lithos

@Cowsquack sì, grazie per averlo raccolto
boboquack il

2

1337 punti

Sicuramente non competitivo, e ci è voluto troppo tempo per crearlo (spero di non aver fatto errori).

Suggerimento:

prova a capire la stringa di origine prima di guardare le regole

Alfabeto: ABEILRSTabcdefijlr

Fonte: SIbbbbbbbdbffacebbfadbdbeecddfaeebddcefaddbdbeeecddaaaaadfaeeebdddcefbbfadbdbdbeeecdddfaeeebdddcefaddbdbeeecddaaaadfaeeebdddcefbfadbdbdbeeecdddfaeeebdddcbdbffacebfadbdbeecddfaeebddceeefadddbdbeeeecddddfaeeeebddddceefaddbdbeeecdddfaeeebdddceefadadbefadfacdbeecddfaeebddcefaeeefaddbdbeeecdddfaeeebdddcceecdfaeeaddceecefaeadcbefadfacecdfaebdceeeeefadddddbdbeeeeeecddddddfaeeeeeebddddddceeefaddaeecdddbdbffacebfadbdbeecddfaeebddceeefadddbdbeeeecddddfaeeeebddddceefaddbdbeeecdddfaeeebdddceefadadbefadfacdbeecddfaeebddcefaeeefaddbdbeeecdddfaeeebdddcceecdfaeeaddceecefaeadcbefadfacecdfaebdcefaefaeeebdddcdcefaceeaaaceefacdffacebdceeeeefadddddbdbeeeeeecddddddfaeeeeeebddddddceeefaddaeecdddbdbffacebfadbdbeecddfaeebddceeefadddbdbeeeecddddfaeeeebddddceefaddbdbeeecdddfaeeebdddceefadadbefadfacdbeecddfaeebddcefaeeefaddbdbeeecdddfaeeebdddcceecdfaeeaddceecefaeadcbefadfacecdfaebdcefaefaeeebdddcdcefaceeaaaaceefacdffacebdcecefacE

Bersaglio: SE

Riscrivi le regole:

Ab: bA
BA: Ab
Aa: aA
aa: aa
Aggiungere un
dA: Ad
Ae: eA
EA: Ae
Af: fA
Fa: Af
Ac: ca
CA: Ac
IA: AI
AI: IA
BB: bB
BB: Bb
Ba: aB
AB: Ba
BD: dB
EB: Be
Be: eB
dB: Bd
BF: fB
FB: Bf
Bc: CB
CB: Bc
E: BE
S: SB
Ib: Abi
AIa: aI
IdB: dBI
BIe: BEI
ASe: AFI
BIfB: BfiLB
Lb: bL
La: aL
Le: eL
Ld: dl
LF: fL
Lc: Cl
ib: bi
ia: ai
Per esempio: ei
id: di
se: fil
lb: bl
la: al
Le: EL
ld: dl
LF: fl
lc: cl
ICL: ci
ICL: cI
Ic: JRC
BJ: jb
aj: ja
dj: jd
ej: je
BR: RB
ar: ra
dr: rd
ER: re
fr: rf
cr: rc
BR: Rb
aR: Ra
dr: Rd
eR: Re
FR: Rf
Cr: Rc
CJ: CCR
FJR: JF
FJR: Se
I: T
TB: T
BT: T
BT: T
AT: T
digitale terrestre
et: T
FT: T
cT: T
T:

2

Nota che inizialmente ho commesso degli errori, quindi il punteggio è stato modificato. Tuttavia, l'idea è la stessa. Spero che non ci siano più errori ora.


154 punti

Alfabeto: P.!xABC[{mD<
Fonte: [x!P.P...P..P.P....P..P.P.....P.P....P......P.P..P...P.P...Pm(61 caratteri)
Target: {CCCCC<(ci sono 5 Cs, quindi 7 caratteri)

Regole:

P.  →  .PP
!.  →  !
x   →  AxB
x   →  
AB  →  BAC
CB  →  BC
CA  →  AC
[B  →  [
[A  →  {
{A  →  {
!   →  !m
mP  →  PmD
Dm  →  mD
DP  →  PD
!P  →  ?
?P  →  ?
!m  →  <
<m  →  <
C<D →  <

Ci sono 19 regole, numero totale di caratteri = 67.


1

106 punti - crackato da HyperNeutrino

Alfabeto: ABCDEFGHIJ

Fonte: FIABCJAGJDEHHID

Bersaglio: F

Riscrivi regole:

B:DCIE
A:IFBA
D:EEFJ
C:GFIC
E:HBJG
F:FEBG
G:HFCJ
H:DIGB
I:FCAH
J:BHEA

EJGI:FF
FFF:J
FF:E
EE:D
DDEA:FI
I:F

Ok, HyperNeutrino ha dimostrato che ciò è irrisolvibile. Tuttavia, esiste un'altra soluzione a questo.


Prendere:

I E C D H G J A F B
1 2 3 4 5 6 7 8 9 10

Il valore della fonte è pari. Il valore del bersaglio è dispari. Se prendiamo ogni lato, sommiamo il valore e prendiamo il valore in mod 2, i valori rimangono gli stessi. Pertanto, ciò non può essere raggiunto.



Se lo desideri, puoi modificare la soluzione desiderata.
Nathaniel

@Nathaniel, okay certo
VortexYT
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.