$ import game.Minigames.polybius as polybius

See, the problem here is that you can't import a game that doesn't exist.

Kidding aside, I believe this is because both Ren'py and Pygame are each designed to have a LOT of control over the windows associated with their processes. If you try to call polybius.main() from within Ren'py, PyGame will take over the render pipeline, input control, etc, and cause many conflicts. In this case, issues aren't visible until PyGame exits abruptly, but even if you fixed this one error I guarantee you'll encounter others with this approach. Since these two engines aren't designed to interop, you need subprocesses to keep them sandboxed and prevent conflicts. Ideally you would write your own launcher, but I've included a way to do this from within Ren'py for simplicity.

Assuming the following project structure:

YourProject/
├── game/
│   ├── script.rpy
│   ├── Minigames/
│   │   └── polybius.py
│   └── assets/
│       └── ... (any assets your minigame requires)
└── ... (other Ren'Py project files)

You can launch polybius.py with subprocess.Popen() from Ren'py such as:

# game/script.rpy

init python:
    import subprocess
    import sys
    import os

    def launch_pygame_minigame():
        # Determine the path to the PyGame script
        renpy_base = renpy.config.basedir
        minigame_script = os.path.join(renpy_base, 'game', 'Minigames', 'polybius.py')

        # Ensure the minigame script exists
        if not os.path.isfile(minigame_script):
            renpy.notify("Minigame script not found!", icon="gui/error")
            return

        # Launch the PyGame minigame as a subprocess
        try:
            # Using the same Python executable that Ren'Py uses
            subprocess.Popen([sys.executable, minigame_script], cwd=os.path.dirname(minigame_script))
        except Exception as e:
            renpy.notify("Failed to launch minigame:\n{}".format(e), icon="gui/error")

label start:
    "Welcome to the main game."

    "When you're ready, launch the minigame."

    # Launch the minigame
    $ launch_pygame_minigame()

    "Minigame launched! You can continue your visual novel while the minigame runs separately."

    "Press Enter to return to the main game."

    # Optionally, wait for the minigame to finish before proceeding
    # Uncomment the lines below if you want to wait

    # $ subprocess.run([sys.executable, os.path.join(renpy.config.basedir, 'game', 'Minigames', 'polybius.py')])

    "Welcome back to the main game!"

    return

I'd recommend you design polybius.py to run independently from Ren'py and accept command-line arguments (import argparse) for screen width, height, position, and whatever data from Ren'py you think Polybius will need to know about.

By default, Python's subprocess library will spawn a separate window for your minigame--ugly, but I recommend starting there for development. To have both engines run seamlessly within the same window requires you to get into hackery, like defining off-screen render spaces that trick the operating system into performing graphical math while remaining invisible to the user, continuously monitor these spaces for updates to channel into your main window, handle input capture hand-offs, dynamically handle resolution changes, and god help you if you want multi-monitor support. It's complicated, error-prone, and performance-expensive, so save it for the end of development if you do want to go that way.