Завайбкодил Мермина-Переса на JS (играть онлайн) - Образование и наука

ИИ заговнокодил игру Мермина-Переса тут: https://jsfiddle.net/4bsfj5wd/

Как играть:

1. Кликаете выбор ведущего (строка и рядок). Подсвечивается.
2. Кликаете выбор Алисы. Алиса знает только строку. Третья ячейка вычисляется по правилам.
3. Аналогично — выбор Боба.

Победа — если игроки угадали и на пересечении значение совпало. Знать точно нельзя, т.к. Алиса получает лишь номер строки от ведущего а Боб лишь номер рядка.

Причина зачем делалось — игру не могли понять по описаниям. Тот же жрец D. Mon пытался объяснить нам, простым смертным, как можно читерить с помощью квантовой запутанности — но не все поняли даже саму суть игры.

А тут все наглядно — можно сыграть и прочувствовать на практике.

Дамп

// ------------------------- ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ -------------------------
const board = document.getElementById('gameBoard');

// Выбранная строка (Алиса) и столбец (Боб)
let currentRow = null;
let currentCol = null;

// Двумерный массив: cellData[row][col] = { alice: '+/-/пусто', bob: '+/-/пусто' }
let cellData = Array.from({ length: 3 }, () =>
  Array.from({ length: 3 }, () => ({ alice: '', bob: '' }))
);

// Ссылка на ячейку (4-я строка) для вывода "ПОБЕДА" или "ПОРАЖЕНИЕ"
let resultCell = null;


// ------------------------- СОЗДАНИЕ ТАБЛИЦЫ -------------------------
(function createBoard() {
  // Создаём 3 строки по 3 ячейки
  for (let i = 0; i < 3; i++) {
    const row = board.insertRow();
    for (let j = 0; j < 3; j++) {
      row.insertCell();
    }
  }
  // 4-я строка: одна ячейка (colSpan=3) для результата
  const resultRow = board.insertRow();
  const cell = resultRow.insertCell();
  cell.colSpan = 3;
  cell.id = 'resultMessageCell';
  resultCell = cell;
})();

// ------------------------- ПОДСВЕТКИ -------------------------
function clearRowHighlights() {
  for (let i = 0; i < 3; i++) {
    board.rows[i].classList.remove('row-highlight');
  }
}

function clearColHighlights() {
  for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      board.rows[i].cells[j].classList.remove('col-highlight');
    }
  }
}

// ------------------------- ВЫБОР СТРОКИ/СТОЛБЦА -------------------------
function chooseRow(rowIndex) {
  clearRowHighlights();
  clearBoardValues();
  currentRow = rowIndex;
  board.rows[rowIndex].classList.add('row-highlight');
  checkIntersection();
}

function chooseCol(colIndex) {
  clearColHighlights();
  clearBoardValues();
  currentCol = colIndex;
  for (let i = 0; i < 3; i++) {
    board.rows[i].cells[colIndex].classList.add('col-highlight');
  }
  checkIntersection();
}

// ------------------------- ОЧИСТКА ПОЛЯ (3x3) -------------------------
function clearBoardValues() {
  for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      const cell = board.rows[i].cells[j];
      cell.textContent = '';
      cell.classList.remove('alice-choice', 'bob-choice');
      cellData[i][j] = { alice: '', bob: '' };
    }
  }
  // Сбросить надпись
  resultCell.textContent = '';
  resultCell.style.color = '';
}

// ------------------------- ОТРИСОВКА ЗНАКОВ -------------------------
function updateCellText(row, col) {
  const data = cellData[row][col];
  const cell = board.rows[row].cells[col];
  const text = `${data.alice || ''}${data.alice && data.bob ? ' / ' : ''}${data.bob || ''}`;
  cell.textContent = text;

  cell.classList.toggle('alice-choice', data.alice !== '');
  cell.classList.toggle('bob-choice', data.bob !== '');
}

// ------------------------- ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ -------------------------

/**
 * inferThird(values, expectedProduct)
 * Если заполнено 2 ячейки из 3, возвращает знак для третьей, чтобы
 * произведение (v1 * v2 * v3) = expectedProduct (1 или -1).
 * Если заполнено <2, возвращает null.
 */
function inferThird(values, expectedProduct) {
  const signs = values.map(v => (v === '+') ? 1 : (v === '-') ? -1 : null);
  const filledCount = signs.filter(s => s !== null).length;
  if (filledCount < 2) return null;

  let product = 1;
  for (let s of signs) {
    if (s !== null) product *= s;
  }
  // Нужно, чтобы итог = expectedProduct
  return (product === expectedProduct) ? '+' : '-';
}

/**
 * fixIfAllThreeFilled(values, expectedProduct)
 * Если все 3 ячейки заполнены, но итоговый продукт != expectedProduct,
 * «переворачиваем» третью (индекс 2).
 */
function fixIfAllThreeFilled(values, expectedProduct) {
  if (values.every(v => v === '+' || v === '-')) {
    // Проверяем произведение
    let product = 1;
    for (let sign of values) {
      product *= (sign === '+') ? 1 : -1;
    }
    if (product !== expectedProduct) {
      // Переворачиваем третью
      values[2] = (values[2] === '+') ? '-' : '+';
    }
  }
  return values;
}

/**
 * checkIntersection()
 * Проверяем «пересекающуюся ячейку» (currentRow,currentCol):
 * Если там стоят оба знака (alice,bob) => ПОБЕДА (совпали) / ПОРАЖЕНИЕ (разные).
 */
function checkIntersection() {
  if (currentRow === null || currentCol === null) {
    resultCell.textContent = '';
    resultCell.style.color = '';
    return;
  }
  const { alice, bob } = cellData[currentRow][currentCol];
  if (!alice || !bob) {
    resultCell.textContent = '';
    resultCell.style.color = '';
    return;
  }
  // Оба знака есть
  if (alice === bob) {
    resultCell.textContent = 'ПОБЕДА';
    resultCell.style.color = 'green';
  } else {
    resultCell.textContent = 'ПОРАЖЕНИЕ';
    resultCell.style.color = 'red';
  }
}

// ------------------------- УПРАВЛЕНИЕ СТРОКАМИ (АЛИСА) -------------------------
function setAliceChoice(index, value) {
  if (currentRow === null) {
    alert("Сначала выберите строку (Алиса)");
    return;
  }
  // Записать новое значение
  cellData[currentRow][index].alice = value;
  updateCellText(currentRow, index);

  // Проверяем, сколько ячеек заполнено, пробуем автодополнение
  let rowValues = cellData[currentRow].map(c => c.alice);
  const thirdSign = inferThird(rowValues, +1); // хотим +1 для Алисы

  if (thirdSign && rowValues.filter(v => v !== '').length === 2) {
    const missingIndex = rowValues.findIndex(v => v === '');
    rowValues[missingIndex] = thirdSign;
  }
  // Если все 3 заполнены, «чиним» при необходимости
  rowValues = fixIfAllThreeFilled(rowValues, +1);

  // Записать обратно и отрисовать
  rowValues.forEach((val, i) => {
    cellData[currentRow][i].alice = val;
    updateCellText(currentRow, i);
  });

  checkIntersection();
}

// ------------------------- УПРАВЛЕНИЕ СТОЛБЦАМИ (БОБ) -------------------------
function setBobChoice(index, value) {
  if (currentCol === null) {
    alert("Сначала выберите столбец (Боб)");
    return;
  }
  // Записать новое значение
  cellData[index][currentCol].bob = value;
  updateCellText(index, currentCol);

  // Автодополнение (ожидаем -1 по столбцу)
  let colValues = [0,1,2].map(r => cellData[r][currentCol].bob);
  const thirdSign = inferThird(colValues, -1);

  if (thirdSign && colValues.filter(v => v !== '').length === 2) {
    const missingIndex = colValues.findIndex(v => v === '');
    colValues[missingIndex] = thirdSign;
  }
  // Если все 3 заполнены, «чиним»
  colValues = fixIfAllThreeFilled(colValues, -1);

  // Записать обратно и отрисовать
  colValues.forEach((val, i) => {
    cellData[i][currentCol].bob = val;
    updateCellText(i, currentCol);
  });

  checkIntersection();
}

<!DOCTYPE html>
<html lang="ru">
<head>
  <meta charset="UTF-8">
  <title>Игра Мермина-Переса</title>
  <!-- Подключаем внешний CSS -->
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <div class="panel">
    <h2>Выбор ведущего</h2>
    <h3>Выбор строки (Алиса)</h3>
    <button onclick="chooseRow(0)">Строка 1</button>
    <button onclick="chooseRow(1)">Строка 2</button>
    <button onclick="chooseRow(2)">Строка 3</button>

    <h3>Выбор столбца (Боб)</h3>
    <button onclick="chooseCol(0)">Столбец 1</button>
    <button onclick="chooseCol(1)">Столбец 2</button>
    <button onclick="chooseCol(2)">Столбец 3</button>
  </div>

  <!-- Таблица 3x3 + четвёртая строка для результата -->
  <table id="gameBoard"></table>

  <div class="panel">
    <h3>Выбор Алисы</h3>
    <div class="row">
      <span>Ячейка 1:</span>
      <button onclick="setAliceChoice(0, '+')">+</button>
      <button onclick="setAliceChoice(0, '-')">-</button>
    </div>
    <div class="row">
      <span>Ячейка 2:</span>
      <button onclick="setAliceChoice(1, '+')">+</button>
      <button onclick="setAliceChoice(1, '-')">-</button>
    </div>

    <h3>Выбор Боба</h3>
    <div class="row">
      <span>Ячейка 1:</span>
      <button onclick="setBobChoice(0, '+')">+</button>
      <button onclick="setBobChoice(0, '-')">-</button>
    </div>
    <div class="row">
      <span>Ячейка 2:</span>
      <button onclick="setBobChoice(1, '+')">+</button>
      <button onclick="setBobChoice(1, '-')">-</button>
    </div>
  </div>

  <!-- Подключаем внешний скрипт (JS) -->
  <script src="script.js"></script>
</body>
</html>

body {
  font-family: sans-serif;
  display: flex;
  justify-content: space-around;
  margin: 20px;
}

.panel {
  display: flex;
  flex-direction: column;
  gap: 10px;
}

.row {
  display: flex;
  align-items: center;
  gap: 5px;
}

button {
  padding: 5px 10px;
  cursor: pointer;
}

table {
  border-collapse: collapse;
  margin-top: 20px;
}

td {
  width: 100px;
  height: 100px;
  border: 1px solid #000;
  text-align: center;
  vertical-align: middle;
  font-size: 24px;
}

.row-highlight {
  background-color: lightgreen;
}

.col-highlight {
  background-color: lightcoral;
}

.alice-choice {
  color: darkgreen;
  font-weight: bold;
}

.bob-choice {
  color: darkred;
  font-weight: bold;
}

/* Ячейка результата (4-я строка таблицы) */
#resultMessageCell {
  border: none;
  font-size: 2em;  
  text-align: center;
  height: auto;
}

Не написал ни одной строчки кода. Ушло примерно час времени, чтобы по шагам объяснить ему одно за другим. Пришлось переходить на модель o1, т.к. обычная уперлась в потолок и начала ломать код.

По сути получается что написать вручную (если работаешь с технологией) — быстрее, чем ему объяснить по шагам. Но! Если ты языка не знаешь или редко на нем пишешь — то быстрее объяснить.

Здравствуйте, Shmj, Вы писали:

S>ИИ заговнокодил игру Мермина-Переса тут: https://jsfiddle.net/4bsfj5wd/

Только почему-то из РФ не открывается. Попробовал через иностранный VPN — открылось.

Здравствуйте, Shmj, Вы писали:

S>ИИ заговнокодил игру Мермина-Переса тут: https://jsfiddle.net/4bsfj5wd/

ИИ становится все лучше и лучше.

Также начинаю потихоньку переходить на "программирование голосом" (в vscode+copilot)
Там еще появилась пачка новых фич, которые можно заюзать (режим copiot editor в частности, не copilot chat, редактирует код за тебя, как те "двое из ларца")
Ты ему просто говоришь (можно голосом) что делать. А он редактирует за тебя код проекта.

Только вчера например: кидаешь ему папку с файлами (HTML/CSS с разметкой например),
говоришь привести их к единому знаменателю (чтобы стили были общие) ну и "вообще облагородить". У меня это конкретно была папка с HTML шаблонами для писем.
Там правила несколько отличаются, чтобы просмотр в веб-браузере (типа GMail или Outlook) не глючил, CSS надо задавать "строже" чем для обычного сайта.
Так вот, удалось ему это втолковать, показывая результат! (т.е. что сломано) o3-mini (o1 супер-дорогой, у меня сразу сразу "семейный бюджет рухнул")
Сам бы я с разметкой точно в разы дольше провозился.

В общем сбор огурцов ждет всех

Здравствуйте, The Minister, Вы писали:

TM>Только почему-то из РФ не открывается. Попробовал через иностранный VPN — открылось.

Ну вот, даже тут вам просто так истину не донесешь — запрещают открывать глаза.

А как же вам можно запустить JS код?

Вот одним HTML-файлом:

Скрытый текст

<!DOCTYPE html>
<html lang="ru">
<head>
  <meta charset="UTF-8">
  <title>Игра Мермина-Переса</title>
  <style>
    body {
      font-family: sans-serif;
      display: flex;
      justify-content: space-around;
      margin: 20px;
    }
    .panel {
      display: flex;
      flex-direction: column;
      gap: 10px;
    }
    .row {
      display: flex;
      align-items: center;
      gap: 5px;
    }
    button {
      padding: 5px 10px;
      cursor: pointer;
    }
    table {
      border-collapse: collapse;
      margin-top: 20px;
    }
    td {
      width: 100px;
      height: 100px;
      border: 1px solid #000;
      text-align: center;
      vertical-align: middle;
      font-size: 24px;
    }
    .row-highlight {
      background-color: lightgreen;
    }
    .col-highlight {
      background-color: lightcoral;
    }
    .alice-choice {
      color: darkgreen;
      font-weight: bold;
    }
    .bob-choice {
      color: darkred;
      font-weight: bold;
    }

    /* Ячейка результата (4-я строка таблицы) */
    td#resultMessageCell {
      border: none;
      font-size: 2em;  
      text-align: center;
      height: auto;
    }
  </style>
</head>
<body>
  <div class="panel">
    <h2>Выбор ведущего</h2>
    <h3>Выбор строки (Алиса)</h3>
    <button onclick="chooseRow(0)">Строка 1</button>
    <button onclick="chooseRow(1)">Строка 2</button>
    <button onclick="chooseRow(2)">Строка 3</button>

    <h3>Выбор столбца (Боб)</h3>
    <button onclick="chooseCol(0)">Столбец 1</button>
    <button onclick="chooseCol(1)">Столбец 2</button>
    <button onclick="chooseCol(2)">Столбец 3</button>
  </div>

  <!-- Таблица 3x3 + четвертая строка для надписи ПОБЕДА/ПОРАЖЕНИЕ -->
  <table id="gameBoard"></table>

  <div class="panel">
    <h3>Выбор Алисы</h3>
    <div class="row">
      <span>Ячейка 1:</span>
      <button onclick="setAliceChoice(0, '+')">+</button>
      <button onclick="setAliceChoice(0, '-')">-</button>
    </div>
    <div class="row">
      <span>Ячейка 2:</span>
      <button onclick="setAliceChoice(1, '+')">+</button>
      <button onclick="setAliceChoice(1, '-')">-</button>
    </div>

    <h3>Выбор Боба</h3>
    <div class="row">
      <span>Ячейка 1:</span>
      <button onclick="setBobChoice(0, '+')">+</button>
      <button onclick="setBobChoice(0, '-')">-</button>
    </div>
    <div class="row">
      <span>Ячейка 2:</span>
      <button onclick="setBobChoice(1, '+')">+</button>
      <button onclick="setBobChoice(1, '-')">-</button>
    </div>
  </div>

  <script>
    // ========================= ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ =========================
    const board = document.getElementById('gameBoard');
    let currentRow = null;
    let currentCol = null;

    // Двумерный массив с объектами: { alice: '+/-/пусто', bob: '+/-/пусто' }
    let cellData = Array.from({ length: 3 }, () =>
      Array.from({ length: 3 }, () => ({ alice: '', bob: '' }))
    );

    // Ссылка на ячейку (4-я строка), в которую пишем "ПОБЕДА" / "ПОРАЖЕНИЕ"
    let resultCell = null;

    // ========================= СОЗДАНИЕ ТАБЛИЦЫ =========================
    function createBoard() {
      // Создаём 3 строки по 3 ячейки
      for (let i = 0; i < 3; i++) {
        const row = board.insertRow();
        for (let j = 0; j < 3; j++) {
          row.insertCell();
        }
      }
      // Добавляем 4-ю строку: одна ячейка (colSpan=3)
      const resultRow = board.insertRow();
      const cell = resultRow.insertCell();
      cell.colSpan = 3;
      cell.id = 'resultMessageCell';
      resultCell = cell;
    }

    // ========================= ПОДСВЕТКИ =========================
    function clearRowHighlights() {
      for (let i = 0; i < 3; i++) {
        board.rows[i].classList.remove('row-highlight');
      }
    }
    function clearColHighlights() {
      for (let i = 0; i < 3; i++) {
        for (let j = 0; j < 3; j++) {
          board.rows[i].cells[j].classList.remove('col-highlight');
        }
      }
    }

    // ========================= ВЫБОР СТРОКИ/СТОЛБЦА =========================
    function chooseRow(rowIndex) {
      clearRowHighlights();
      clearBoardValues();
      currentRow = rowIndex;
      board.rows[rowIndex].classList.add('row-highlight');
      checkIntersection();
    }

    function chooseCol(colIndex) {
      clearColHighlights();
      clearBoardValues();
      currentCol = colIndex;
      for (let i = 0; i < 3; i++) {
        board.rows[i].cells[colIndex].classList.add('col-highlight');
      }
      checkIntersection();
    }

    // ========================= ОЧИСТКА ПОЛЯ (3x3) =========================
    // Не трогаем 4-ю строку, а лишь стираем сообщение
    function clearBoardValues() {
      for (let i = 0; i < 3; i++) {
        for (let j = 0; j < 3; j++) {
          const cell = board.rows[i].cells[j];
          cell.textContent = '';
          cell.classList.remove('alice-choice', 'bob-choice');
          cellData[i][j] = { alice: '', bob: '' };
        }
      }
      resultCell.textContent = '';
      resultCell.style.color = '';
    }

    // ========================= ОТРИСОВКА ЗНАКОВ =========================
    function updateCellText(row, col) {
      const data = cellData[row][col];
      const cell = board.rows[row].cells[col];
      const text = `${data.alice || ''}${data.alice && data.bob ? ' / ' : ''}${data.bob || ''}`;
      cell.textContent = text;
      cell.classList.toggle('alice-choice', data.alice !== '');
      cell.classList.toggle('bob-choice', data.bob !== '');
    }

    // ========================= ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ =========================

    // Возвращает '+' или '-' для «третьей» ячейки, если уже 2 ячейки заполнены,
    // чтобы итоговое произведение (v1*v2*v3) = expectedProduct.
    // Если заполнено меньше 2, вернёт null (автодополнение пока невозможно).
    function inferThird(values, expectedProduct) {
      // Переводим в массив чисел: + => 1, - => -1, '' => null
      const signs = values.map(v => (v === '+') ? 1 : (v === '-') ? -1 : null);
      const filledCount = signs.filter(s => s !== null).length;
      if (filledCount < 2) return null;

      // Произведение уже заполненных
      let product = 1;
      for (let s of signs) {
        if (s !== null) product *= s;
      }
      // Если currentProduct = product, чтобы достигнуть expectedProduct
      // нам нужен знак: + (1), если product == expectedProduct, иначе - ( -1 ).
      return (product === expectedProduct) ? '+' : '-';
    }

    // Если все 3 ячейки уже заполнены, но их произведение не совпадает с expectedProduct,
    // «переворачиваем» именно третью ячейку (индекс 2).
    // Возвращаем обновлённый массив строк вида ['+','+','-'].
    function fixIfAllThreeFilled(values, expectedProduct) {
      // Проверим, действительно ли 3 заполнены
      if (values.every(v => v === '+' || v === '-')) {
        // Считаем текущее произведение
        let product = 1;
        for (let sign of values) {
          product *= (sign === '+') ? 1 : -1;
        }
        // Если не совпадает, «переворачиваем» последнюю ячейку
        if (product !== expectedProduct) {
          const last = values[2]; // (индекс 2 - третья)
          values[2] = (last === '+') ? '-' : '+';
        }
      }
      return values;
    }

    // Проверяет «пересекающуюся ячейку» (currentRow, currentCol).
    // Если там (alice,bob) оба уже стоят, выводит ПОБЕДА/ПОРАЖЕНИЕ.
    function checkIntersection() {
      if (currentRow === null || currentCol === null) {
        resultCell.textContent = '';
        resultCell.style.color = '';
        return;
      }
      const { alice, bob } = cellData[currentRow][currentCol];
      if (!alice || !bob) {
        resultCell.textContent = '';
        resultCell.style.color = '';
        return;
      }
      // Оба знака есть, проверяем совпадение
      if (alice === bob) {
        resultCell.textContent = 'ПОБЕДА';
        resultCell.style.color = 'green';
      } else {
        resultCell.textContent = 'ПОРАЖЕНИЕ';
        resultCell.style.color = 'red';
      }
    }

    // ========================= ФУНКЦИИ ВЫБОРА АЛИСЫ =========================
    // Строка Алисы должна иметь произведение +1
    function setAliceChoice(index, value) {
      if (currentRow === null) {
        alert("Сначала выберите строку (Алиса)");
        return;
      }
      // 1) Записываем новое значение
      cellData[currentRow][index].alice = value;
      updateCellText(currentRow, index);

      // 2) Смотрим, сколько ячеек заполнено
      let rowValues = cellData[currentRow].map(c => c.alice); // 3 значения ( + / - / '' )

      // Если ровно 2 заполнены, автодополняем третью
      const thirdSign = inferThird(rowValues, +1);
      if (thirdSign && rowValues.filter(v => v !== '').length === 2) {
        const missingIndex = rowValues.findIndex(v => v === '');
        rowValues[missingIndex] = thirdSign;
      }

      // Если все 3 заполнены, «чинim» при необходимости
      rowValues = fixIfAllThreeFilled(rowValues, +1);

      // 3) Записываем обратно в cellData и обновляем ячейки
      rowValues.forEach((val, i) => {
        cellData[currentRow][i].alice = val;
        updateCellText(currentRow, i);
      });

      // 4) Проверяем пересечение
      checkIntersection();
    }

    // ========================= ФУНКЦИИ ВЫБОРА БОБА =========================
    // Столбец Боба должен иметь произведение -1
    function setBobChoice(index, value) {
      if (currentCol === null) {
        alert("Сначала выберите столбец (Боб)");
        return;
      }
      // 1) Записать новое значение
      cellData[index][currentCol].bob = value;
      updateCellText(index, currentCol);

      // 2) Аналогичные шаги — но для столбца
      let colValues = [0,1,2].map(r => cellData[r][currentCol].bob);
      const thirdSign = inferThird(colValues, -1);

      if (thirdSign && colValues.filter(v => v !== '').length === 2) {
        const missingIndex = colValues.findIndex(v => v === '');
        colValues[missingIndex] = thirdSign;
      }

      // Если все 3 ячейки заполнены, «чиним»
      colValues = fixIfAllThreeFilled(colValues, -1);

      // Записываем обратно
      colValues.forEach((val, i) => {
        cellData[i][currentCol].bob = val;
        updateCellText(i, currentCol);
      });

      // 3) Проверка пересечения
      checkIntersection();
    }

    // ========================= ИНИЦИАЛИЗАЦИЯ =========================
    createBoard();
  </script>
</body>
</html>

Здравствуйте, bnk, Вы писали:

bnk>Сам бы я с разметкой точно в разы дольше провозился.

Разметка ему дается очень хорошо, видимо потому что там нет сложных ветвлений и циклов.

А вот эту игру — даже ее не просто было написать. И чем больше логики — тем сложнее, в конечном итоге как бы упирается в стену и начинает ломать, так что возникает желание самому написать, ибо тщетные попытки вразумить ИИ отнимают много времени.

bnk>В общем сбор огурцов ждет всех

Не спешите. Я тоже раньше думал так, а теперь смотрю что замедлилось развитие значительно. А результаты по-прежнему далеки от желаемых

Здравствуйте, Shmj, Вы писали:

S>ИИ заговнокодил игру Мермина-Переса тут: https://jsfiddle.net/4bsfj5wd/

Если я правильно понял, ваш код пока только демонстрирует, что без квантовой запутанности можно выигрывать максимум в 8 случаях из 9?

Здравствуйте, Khimik, Вы писали:

S>>ИИ заговнокодил игру Мермина-Переса тут: https://jsfiddle.net/4bsfj5wd/
K>Если я правильно понял, ваш код пока только демонстрирует, что без квантовой запутанности можно выигрывать максимум в 8 случаях из 9?

Да, просто дает поиграть классически и прочувствовать правила игры на своей шкуре.

Написать квантовый алгоритм пока не удалось. Вроде нужно 9 кубитов запутанных особым образом, а пока нет под рукой такого симулятора 9-кубитного. IBM Quantum дает только 4 кубита

Здравствуйте, Shmj, Вы писали:

S>Вроде нужно 9 кубитов запутанных особым образом, а пока нет под рукой такого симулятора 9-кубитного. IBM Quantum дает только 4 кубита

9 как раз не нужно, нужно 4. У Алисы в каждом ряду 3 пары операторов, но она не измеряет 3 разных пары кубитов, она все три пары измерений проводит над одной парой кубитов, в одну операцию. 2 кубита ей и 2 Бобу.

Здравствуйте, D. Mon, Вы писали:

DM>9 как раз не нужно, нужно 4. У Алисы в каждом ряду 3 пары операторов, но она не измеряет 3 разных пары кубитов, она все три пары измерений проводит над одной парой кубитов, в одну операцию. 2 кубита ей и 2 Бобу.

Благодарю. А вам не попадался код на QASM для случая 3 3, к примеру. GPT o1 в режиме Deep Research выдал такое:

OPENQASM 2.0;
include "qelib1.inc";

qreg q[4];
creg cAlice[2];
creg cBob[2];

// Подготовка двух пар Белла (состояние |Φ+> = (|00>+|11>)/√2 на парах q[0]-q[2] и q[1]-q[3]):
h q[0];                 // Применяем Hadamard к A1
cx q[0], q[2];          // CNOT от A1 к B1 создает запутанное состояние между q0 и q2
h q[1];                 // Hadamard к A2
cx q[1], q[3];          // CNOT от A2 к B2 (вторая пара запутывается)

// Настройка базисов измерения для случая (строка 3, столбец 3):
// Здесь выбран Y-базис для всех четырех кубитов (Sdg + H перед измерением)
sdg q[0];
h q[0];
sdg q[1];
h q[1];
sdg q[2];
h q[2];
sdg q[3];
h q[3];


//x q[2];
x q[3]; // Методом тыка - так работает для 3 3, но не точно

// Измерение кубитов Алисы и Боба в выбранных базисах
measure q[0] -> cAlice[0];    // измерение A1 
measure q[1] -> cAlice[1];    // измерение A2
measure q[2] -> cBob[0];      // измерение B1
measure q[3] -> cBob[1];      // измерение B2

Но оно дает ошибочные результаты — вот тут можно проверить без регистрации и СМС: https://quantum.ibm.com/composer/

Подозрение на настройку базисов. Но я могу понять только когда будет рабочий код, пока кода нет — ничего понять не могу.

Вообще, по идее, должно быть 3 преобразования у Алисы и 3 у Боба. Причем Алиса применяет в зависимости от номера строки а Боб в зависимости от номера столбца.

GPT решить не может.

По этому вопрос этих 6 кусков кода остается открытым, может когда-нибудь кто-нибудь решит.

	От:	Shmj
	Дата:	29.03.25 10:03
	Оценка:	14 (2) +1

	От:	The Minister
	Дата:	29.03.25 11:48
	Оценка:

От:	bnk	http://unmanagedvisio.com/
Дата:	29.03.25 11:56
Оценка:

	От:	Shmj
	Дата:	29.03.25 12:00
	Оценка:

	От:	Shmj
	Дата:	29.03.25 17:32
	Оценка:	+2

От:	D. Mon	http://thedeemon.livejournal.com
Дата:	30.03.25 12:23
Оценка:	82 (2)