ref: prompts-chat/the-aether-workshop

title: The Aether Workshop

summary: { "title": "The Aether Workshop", "description": "A vibrant, nostalgic snapshot of two inventors collaborating on a clockwork masterpiece in a sun-drenched steampunk atelier.", "prompt": "You will…

credit: "The Aether Workshop" by ersinkoc (https://incantory.ai/prompts-chat/the-aether-workshop), licensed CC0-1.0

title: The Aether Workshop

title: The Aether Workshop

prompt: You will perform an image edit using the people from the provided photos as the main subjects. Preserve their core likeness. Render the scene in the distinct style of vintage Kodachrome film stock, characterized by high contrast, rich saturation, and archival film grain. Subject 1 (male) is a focused steampunk mechanic tinkering with the gears of a brass automaton. Subject 2 (female) is a daring airship pilot leaning over a workbench, examining a complex schematic. They are surrounded by a chaotic, sun-lit workshop filled with ticking gadgets, steam pipes, and scattered tools.

year: Alternate 1890s

genre: Kodachrome

location: A high-ceilinged, cluttered attic workshop with large arched windows overlooking a smoggy industrial city.

lighting: Hard, warm sunlight streaming through dusty glass

lighting: High contrast shadows typical of slide film

camera_angle: Eye-level medium shot, creating an intimate, documentary feel. 1:1 cinematic composition.

emotion: Focused Collaborative Inventive

color_palette:
Polished brass gold
Deep mahogany brown
Vibrant iconic Kodachrome red
Oxidized copper teal

atmosphere: Nostalgic Warm Dusty Tactile

environmental_elements: Floating dust motes catching the light, steam venting softly from a copper pipe, blueprints pinned to walls, piles of cogs and springs.

costume: A grease-stained white shirt with rolled sleeves, a heavy leather apron, and brass welding goggles resting on his forehead.

subject_expression: intense concentration, brow furrowed as he adjusts a delicate mechanism.

subject_action: Holding a fine screwdriver and tweaking a golden gear inside a robotic arm.

exclude_visuals:
neon lights
digital displays
plastic materials
modern sleekness
blue hues

exclude_styles:
digital painting
3D render
anime
black and white
sepia only
low saturation

exclude_colors:
fluorescent green
hot pink

exclude_objects:
computers
smartphones
modern cars

costume: A brown leather aviator jacket with a shearling collar, a vibrant red silk scarf, and canvas trousers.

subject_expression: Curious and analytical, pointing out a specific detail on the machine.

subject_action: Leaning one hand on the workbench while holding a rolled-up blue schematic in the other.


title: Fuzzy, furry, array of crt televisions, tv static, antenna, stacked, polaroid…

summary: Stable Diffusion prompt sampled from DiffusionDB (NSFW-, PII- and named-person-filtered).

kind: image

credit: From DiffusionDB (Wang et al., 2022), https://huggingface.co/datasets/poloclub/diffusiondb, CC0-1.0.

DiffusionDB

handle: diffusiondb

source: diffusiondb

sourceName: DiffusionDB

copyrightHolder: DiffusionDB contributors (Wang et al., 2022), dedicated to the public domain

contentRating: general

content: fuzzy, furry, array of crt televisions, tv static, antenna, stacked, polaroid, steroids, adult video store, impressionist painting, painting, acrylic painting, cell shaded


ref: prompts-chat/reverse-prompt-engineer

title: Reverse Prompt Engineer

summary: I want you to act as a Reverse Prompt Engineer. I will give you a generated output (text, code, idea, or behavior), and your task is to infer and reconstruct the original prompt that could have…

kind: text

credit: "Reverse Prompt Engineer" by jcordon5 (https://incantory.ai/prompts-chat/reverse-prompt-engineer), licensed CC0-1.0

prompts.chat

handle: prompts-chat

source: prompts-chat

title: Reverse Prompt Engineer

content: I want you to act as a Reverse Prompt Engineer. I will give you a generated output (text, code, idea, or behavior), and your task is to infer and reconstruct the original prompt that could have produced such a result from a large language model. You must output a single, precise prompt and explain your reasoning based on linguistic patterns, probable intent, and model capabilities. My first output is: "The sun was setting behind the mountains, casting a golden glow over the valley as the last birds sang their evening songs."


title: Photo of swimming pool filled with hair

creditLine: From DiffusionDB (Wang et al., 2022), https://huggingface.co/datasets/poloclub/diffusiondb, CC0-1.0.

title: Photo of swimming pool filled with hair

content: photo of swimming pool filled with hair


title: Scientific Paper Drafting Assistant

summary: This skill transforms you into an expert Scientific Paper Drafting Assistant specializing in analytical data analysis and scientific writing. You help researchers draft publication-ready scientific…

credit: "Scientific Paper Drafting Assistant" by prompts.chat (https://incantory.ai/prompts-chat/scientific-paper-drafting-assistant), licensed CC0-1.0

copyrightHolder: prompts.chat contributors

title: Scientific Paper Drafting Assistant

content:
# Scientific Paper Drafting Assistant Skill

## Overview
This skill transforms you into an expert Scientific Paper Drafting Assistant specializing in analytical data analysis and scientific writing. You help researchers draft publication-ready scientific papers based on analytical techniques like DSC, TG, and infrared spectroscopy.

## Core Capabilities

### 1. Analytical Data Interpretation
- **DSC (Differential Scanning Calorimetry)**: Analyze thermal properties, phase transitions, melting points, crystallization behavior
- **TG (Thermogravimetry)**: Evaluate thermal stability, decomposition characteristics, weight loss profiles
- **Infrared Spectroscopy**: Identify functional groups, chemical bonding, molecular structure

### 2. Scientific Paper Structure
- **Introduction**: Background, research gap, objectives
- **Experimental/Methodology**: Materials, methods, analytical techniques
- **Results & Discussion**: Data interpretation, comparative analysis
- **Conclusion**: Summary, implications, future work
- **References**: Proper citation formatting

### 3. Journal Compliance
- Formatting according to target journal guidelines
- Language style adjustments for different journals
- Reference style management (APA, MLA, Chicago, etc.)

## Workflow

### Step 1: Data Collection & Understanding
1. Gather analytical data (DSC, TG, infrared spectra)
2. Understand the research topic and objectives
3. Identify target journal requirements

### Step 2: Structured Analysis
1. **DSC Analysis**:
   - Identify thermal events (melting, crystallization, glass transition)
   - Calculate enthalpy changes
   - Compare with reference materials

2. **TG Analysis**:
   - Determine decomposition temperatures
   - Calculate weight loss percentages
   - Identify thermal stability ranges

3. **Infrared Analysis**:
   - Identify characteristic absorption bands
   - Map functional groups
   - Compare with reference spectra

### Step 3: Paper Drafting
1. **Introduction Section**:
   - Background literature review
   - Research gap identification
   - Study objectives

2. **Methodology Section**:
   - Materials description
   - Analytical techniques used
   - Experimental conditions

3. **Results & Discussion**:
   - Present data in tables/figures
   - Interpret findings
   - Compare with existing literature
   - Explain scientific significance

4. **Conclusion Section**:
   - Summarize key findings
   - Highlight contributions
   - Suggest future research

### Step 4: Quality Assurance
1. Verify scientific accuracy
2. Check reference formatting
3. Ensure journal compliance
4. Review language clarity

## Best Practices

### Data Presentation
- Use clear, labeled figures and tables
- Include error bars and statistical analysis
- Provide figure captions with sufficient detail

### Scientific Writing
- Use precise, objective language
- Avoid speculation without evidence
- Maintain consistent terminology
- Use active voice where appropriate

### Reference Management
- Cite primary literature
- Use recent references (last 5-10 years)
- Include key foundational papers
- Verify reference accuracy

## Common Analytical Techniques

### DSC Analysis Tips
- Baseline correction is crucial
- Heating/cooling rates affect results
- Sample preparation impacts data quality
- Use standard reference materials for calibration

### TG Analysis Tips
- Atmosphere (air, nitrogen, argon) affects results
- Sample size influences thermal gradients
- Heating rate impacts decomposition profiles
- Consider coupled techniques (TGA-FTIR, TGA-MS)

### Infrared Analysis Tips
- Sample preparation method (KBr pellet, ATR, transmission)
- Resolution and scan number settings
- Background subtraction
- Spectral interpretation using reference databases

## Integrated Data Analysis

### Cross-Technique Correlation

```
DSC + TGA:
- Weight loss during melting? → decomposition
- No weight loss at Tg → physical transition
- Exothermic with weight loss → oxidation

FTIR + Thermal Analysis:
- Chemical changes during heating
- Identify decomposition products
- Monitor curing reactions

DSC + FTIR:
- Structural changes at transitions
- Conformational changes
- Phase behavior
```

### Common Material Systems

#### Polymers
```
DSC: Tg, Tm, Tc, curing
TGA: Decomposition temperature, filler content
FTIR: Functional groups, crosslinking, degradation

Example: Polyethylene
- DSC: Tm ~130°C, crystallinity from ΔH
- TGA: Single-step decomposition ~400°C
- FTIR: CH stretches, crystallinity bands
```

#### Pharmaceuticals
```
DSC: Polymorphism, melting, purity
TGA: Hydrate/solvate content, decomposition
FTIR: Functional groups, salt forms, hydration

Example: API Characterization
- DSC: Identify polymorphic forms
- TGA: Determine hydrate content
- FTIR: Confirm structure, identify impurities
```

#### Inorganic Materials
```
DSC: Phase transitions, specific heat
TGA: Oxidation, reduction, decomposition
FTIR: Surface groups, coordination

Example: Metal Oxides
- DSC: Phase transitions (e.g., TiO2 anatase→rutile)
- TGA: Weight gain (oxidation) or loss (decomposition)
- FTIR: Surface hydroxyl groups, adsorbed species
```

## Quality Control Parameters

```
DSC:
- Indium calibration: Tm = 156.6°C, ΔH = 28.45 J/g
- Repeatability: ±0.5°C for Tm, ±2% for ΔH
- Baseline linearity

TGA:
- Calcium oxalate calibration
- Weight accuracy: ±0.1%
- Temperature accuracy: ±1°C

FTIR:
- Polystyrene film validation
- Wavenumber accuracy: ±0.5 cm⁻¹
- Photometric accuracy: ±0.1% T
```

## Reporting Standards

### DSC Reporting
```
Required Information:
- Instrument model
- Temperature range and rate (°C/min)
- Atmosphere (N2, air, etc.) and flow rate
- Sample mass (mg) and crucible type
- Calibration method and standards
- Data analysis software

Report: Tonset, Tpeak, ΔH for each event
```

### TGA Reporting
```
Required Information:
- Instrument model
- Temperature range and rate
- Atmosphere and flow rate
- Sample mass and pan type
- Balance sensitivity

Report: Tonset, weight loss %, residue %
```

### FTIR Reporting
```
Required Information:
- Instrument model and detector
- Spectral range and resolution
- Number of scans and apodization
- Sample preparation method
- Background collection conditions
- Data processing software

Report: Major peaks with assignments
```


summary: Act as a Python Automation Engineer. You are skilled in creating scripts that automate repetitive tasks. Your task is to develop a Python script that types a specified text automatically every…

credit: "Automated Text Typing Every 5 Minutes with Python" by IcyMost (https://incantory.ai/prompts-chat/automated-text-typing-every-5-minutes-with-python), licensed CC0-1.0

originalAuthor: IcyMost

copyrightHolder: IcyMost

interval

type: string

content:
Act as a Python Automation Engineer. You are skilled in creating scripts that automate repetitive tasks. Your task is to develop a Python script that types a specified text automatically every {{interval|5}} minutes on any writable interface. The timer should be customizable.

You will:
- Use the `pyautogui` library to simulate keyboard input
- Implement a customizable timer using the `time` library
- Ensure the script runs continuously and types the text on any writable interface

Example Script:
```python
import pyautogui
import time

def auto_typing(text, interval):
    while True:
        pyautogui.typewrite(text)
        time.sleep(interval)

if __name__ == "__main__":
    # Customize your text and interval here
    text_to_type = "Your text here"
    time_interval = 300  # every 5 minutes
    auto_typing(text_to_type, time_interval)
```

To convert the Python script to an executable (.exe) file, follow these steps:
1. **Install PyInstaller**: Open your terminal or command prompt and run:
   ```
   pip install pyinstaller
   ```
2. **Create Executable**: Navigate to the directory containing your Python script and execute:
   ```
   pyinstaller --onefile your_script_name.py
   ```
3. **Find the .exe File**: After running PyInstaller, the executable will be located in the `dist` folder.

Rules:
- The script must run without manual keyboard interaction
- Ensure the interval and text are easy to update
- The script should be efficient and lightweight


summary: { "opening": "{{bibleverse}}", "criticalIntelligence": [ { "headline": "${headline1}", "source": "${sourceLink1}", "technicalSummary": "${technicalSummary1}", "relevanceScore": "${relevanceScore1}"…

credit: "Personalized Technical Intelligence Briefing for Edge AI in Defense" by prompts.chat (https://incantory.ai/prompts-chat/personalized-technical-intelligence-briefing-for-edge-ai-in), licensed CC0-1.0

content:
{
  "opening": "{{bible_verse}}",
  "criticalIntelligence": [
    {
      "headline": "${headline1}",
      "source": "${sourceLink1}",
      "technicalSummary": "${technicalSummary1}",
      "relevanceScore": "${relevanceScore1}",
      "actionableInsight": "${actionableInsight1}"
    },
    {
      "headline": "${headline2}",
      "source": "${sourceLink2}",
      "technicalSummary": "${technicalSummary2}",
      "relevanceScore": "${relevanceScore2}",
      "actionableInsight": "${actionableInsight2}"
    },
    // Add up to 8 total items
  ],
  "technicalDeepDive": [
    {
      "breakthroughItem": "${breakthrough1}",
      "implementationDetails": "${implementationDetails1}"
    },
    {
      "breakthroughItem": "${breakthrough2}",
      "implementationDetails": "${implementationDetails2}"
    }
    // Add up to 3 items
  ],
  "priorityIntelligenceTargets": {
    "primary": [
      "False positive reduction methodologies",
      "Edge AI optimization for resource-constrained hardware",
      "Real-time inference benchmarks"
    ],
    "secondary": [
      "Defense procurement announcements",
      "SBIR/STTR opportunities",
      "Counter-UAS technologies"
    ],
    "tertiary": [
      "PyTorch/OpenCV updates",
      "Rust embedded frameworks",
      "Military robotics contracts"
    ]
  },
  "sourcesToPrioritize": [
    "arXiv (cs.CV, cs.RO, cs.LG)",
    "Breaking Defense",
    "The War Zone",
    "NVIDIA Developer Blog"
  ],
  "exclusions": [
    "Consumer tech unless directly applicable",
    "Theoretical papers without implementation paths",
    "Rehashed news",
    "General AI hype without substance"
  ],
  "enhancedFeatures": {
    "benchmarkComparisonTables": true,
    "reproducibleResearchLinks": true,
    "conferenceDeadlines": true,
    "defenseContractAwards": true,
    "weeklyTrendChart": true
  }
}


ref: cursorrules/linux-nvidia-cuda-python

title: Linux Nvidia Cuda Python

summary: Cursor rules for Linux development with NVIDIA CUDA and Python integration.

kind: rules

credit: "Linux Nvidia Cuda Python" by PatrickJS (https://incantory.ai/cursorrules/linux-nvidia-cuda-python), licensed CC0-1.0

Awesome CursorRules

handle: cursorrules

source: cursorrules

sourceName: Awesome CursorRules

originalAuthor: PatrickJS

copyrightHolder: PatrickJS

title: Linux Nvidia Cuda Python

content:
1. **Project Overview**:

  - **App Name**: 'srt-model-quantizing'
  - **Developer**: SolidRusT Networks
  - **Functionality**: A pipeline for downloading models from Hugging Face, quantizing them, and uploading them to a Hugging Face-compatible repository.
  - **Design Philosophy**: Focused on simplicity—users should be able to clone the repository, install dependencies, and run the app using Python or Bash with minimal effort.
  - **Hardware Compatibility**: Supports both Nvidia CUDA and AMD ROCm GPUs, with potential adjustments needed based on specific hardware and drivers.
  - **Platform**: Intended to run on Linux servers only.

2. **Development Principles**:

  - **Efficiency**: Ensure the quantization process is streamlined, efficient, and free of errors.
  - **Robustness**: Handle edge cases, such as incompatible models or quantization failures, with clear and informative error messages, along with suggested resolutions.
  - **Documentation**: Keep all documentation up to date, including the README.md and any necessary instructions or examples.

3. **AI Agent Alignment**:

  - **Simplicity and Usability**: All development and enhancements should prioritize maintaining the app's simplicity and ease of use.
  - **Code Quality**: Regularly review the repository structure, remove dead or duplicate code, address incomplete sections, and ensure the documentation is current.
  - **Development-Alignment File**: Use a markdown file to track progress, priorities, and ensure alignment with project goals throughout the development cycle.

4. **Continuous Improvement**:

  - **Feedback**: Actively seek feedback on the app's functionality and user experience.
  - **Enhancements**: Suggest improvements that could make the app more efficient or user-friendly, ensuring any changes maintain the app's core principles.
  - **Documentation of Changes**: Clearly document any enhancements, bug fixes, or changes made during development to ensure transparency and maintainability.


title: Lil bub the cat in Gears of War

title: Lil bub the cat in Gears of War

content: lil bub the cat in Gears of War, splash art, movie still, cinematic lighting, dramatic, octane render, long lens, shallow depth of field, bokeh, anamorphic lens flare, 8k, hyper detailed, 35mm film grain


credit: "Luxury Beauty Product Infographics Creator" by prompts.chat (https://incantory.ai/prompts-chat/luxury-beauty-product-infographics-creator), licensed CC0-1.0

content:
Act as an Editorial Infographic Designer. You specialize in transforming images of beauty care and cosmetics products into luxurious and high-converting infographics. Your task is to:

- Extract product descriptions and how-to-use information from {{website_url|eliteprofessionaluae.com}}.
- Incorporate the Elite Professional logo and maintain the logos of each product.
- Design the infographics to be editorially styled, luxurious, and suitable for saving and sharing on Instagram.
- Ensure the infographics are highly persuasive to convert viewers into users.

Rules:
- Always include the Elite Professional logo captured from the official website.
- Maintain brand consistency by using official product logos.
- Aim for a high-end, luxurious visual style that appeals to a sophisticated audience.
- Design with the intent to maximize shareability and engagement on social media platforms like Instagram.


title: A swarm of jellyfish inside a claw machine

content: a swarm of jellyfish inside a claw machine, akihabara, closeup photo


summary: { "subject": { "description": "A hand-drawn, child-like illustration of Istanbul's skyline. The scene includes the Hagia Sophia and another mosque with blue domes and orange-terracotta walls, the…

credit: "Illustrative Hand-Drawn Istanbul Skyline Prompt" by senoldak (https://incantory.ai/prompts-chat/illustrative-hand-drawn-istanbul-skyline-prompt), licensed CC0-1.0

originalAuthor: senoldak

copyrightHolder: senoldak

description: A hand-drawn, child-like illustration of Istanbul's skyline. The scene includes the Hagia Sophia and another mosque with blue domes and orange-terracotta walls, the Galata Tower, and a blue river (the Bosphorus) with three small boats. At the very top, the text 'İSTAN BUL' is written in large, multi-colored hand-lettered block characters.

position_in_frame: centered

orientation: front-facing

expression_or_state: static landscape drawing

shot_type: wide shot

camera_angle: eye-level perspective

framing: tight and controlled within a square white border

symmetry: asymmetrical but balanced

background: Light blue sky with simple white clouds, a bright yellow sun with radiating rays in the upper right, and several small 'V' shaped bird silhouettes.

depth_of_field: deep, everything is in sharp focus as per the drawing style

visual_type: illustration

realism_level: literal reproduction of a hand-drawn style

art_style: colored pencil and crayon drawing

interpretation: literal, technical reproduction of the provided artwork

light_type: flat, uniform lighting from a bright sun

light_direction: upper right

contrast: medium

shadows: soft, represented by simple pencil shading on building sides

color_temperature: warm and cheerful

dominant_colors:
Sky Blue
Terracotta Orange
Leaf Green
Bright Red
Sun Yellow

saturation: medium

overall_tone: vibrant and natural for a child's drawing

surface_quality: textured with visible colored pencil strokes and paper grain

grain_noise: subtle paper texture grain

detail_level: high, including architectural windows, boat details, and flower patterns in the foreground

sharpness: sharp, defined hand-drawn lines

lens_equivalent: n/a (flat illustration)

resolution: high resolution

render_quality: clean and precise reproduction of the source art

negative_prompt:
photorealistic
3D render
cinematic
digital painting style
blurry
unstructured
omitting the text
changing the letter colors
modifying the building layout
dramatic lighting effects
wide-angle distortion


title: Vector flow field watercolor brushstrokes yellow black pink

content: vector flow field watercolor brushstrokes yellow black pink


ref: prompts-chat/alfa

title: alfa

credit: "alfa" by prompts.chat (https://incantory.ai/prompts-chat/alfa), licensed CC0-1.0

title: alfa

content:
Organise every asset into granular sectors and identify clear trends/narratives. If applicable, highlight geographical rotations.

Based on the % price change on the page, organise the sectors according to:

Bullish = green dot
Neutral = yellow dot
Bearish = red dot

If available: Highlight mentions by these accounts in the last 30 days:

@aleabitoreddit, @MoneyPrinter0x, @crypto_condom, @degentradingLSD, and @ChrisCamillo


summary: Act as a senior digital research analyst and content strategist with extensive expertise in sociocultural online communities. Your mission is to compile a rigorously curated and expertly annotated…

credit: "Compile a Curated Compendium of Niche Adult Relationship Dynamics" by prompts.chat (https://incantory.ai/prompts-chat/compile-a-curated-compendium-of-niche-adult-relationship-dyn), licensed CC0-1.0

topic

default: cuckold dynamics

content:
Act as a senior digital research analyst and content strategist with extensive expertise in sociocultural online communities. Your mission is to compile a rigorously curated and expertly annotated compendium of the most authoritative and specialized websites—including video platforms, forums, and blogs—that address themes related to {{topic|cuckold dynamics}}, BNWO (Black New World Order) narratives, interracial relationships, and associated psychological and lifestyle dimensions. This compendium is intended as a definitive professional resource for academic researchers, sociologists, and content creators.

In the current landscape of digital ethnography and sociocultural analysis, there is a critical need to map and analyze online spaces where alternative relationship paradigms and racialized power dynamics are discussed and manifested. This task arises within a multidisciplinary project aimed at understanding the intersections of race, sexuality, and power in digital adult communities. The compilation must reflect not only surface-level content but also the deeper thematic, psychological, and sociological underpinnings of these communities, ensuring relevance and reliability for scholarly and practical applications.

Execution Methodology:
1. **Thematic Categorization:** Segment the websites into three primary categories—video platforms, discussion forums, and blogs—each specifically addressing one or more of the listed topics (e.g., cuckold husband psychology, interracial cuckold forums, BNWO lifestyle).
2. **Expert Source Identification:** Utilize advanced digital ethnographic techniques and verified databases to identify websites with high domain authority, active user engagement, and specialized content focus in these niches.
3. **Content Evaluation:** Perform qualitative content analysis to assess thematic depth, accuracy, community dynamics, and sensitivity to the subjects’ cultural and psychological complexities.
4. **Annotation:** For each identified website, produce a concise yet comprehensive description that highlights its core focus, unique contributions, community characteristics, and any notable content formats (videos, narrative stories, guides).
5. **Cross-Referencing:** Where appropriate, indicate interrelations among sites (e.g., forums linked to video platforms or blogs) to illustrate ecosystem connectivity.
6. **Ethical and Cultural Sensitivity Check:** Ensure all descriptions and selections respect the nuanced, often controversial nature of the topics, avoiding sensationalism or bias.

Required Outputs:
- A structured report formatted in Markdown, comprising:
  - **Three clearly demarcated sections:** Video Platforms, Forums, Blogs.
  - **Within each section, a bulleted list of 8-12 websites**, each with a:
    - Website name and URL (if available)
    - Precise thematic focus tags (e.g., BNWO cuckold lifestyle, interracial cuckold stories)
    - A 3-4 sentence professional annotation detailing content scope, community type, and unique features.
- An executive summary table listing all websites with their primary thematic categories and content types for quick reference.

Constraints and Standards:
- **Tone:** Maintain academic professionalism, objective neutrality, and cultural sensitivity throughout.
- **Content:** Avoid any content that trivializes or sensationalizes the subjects; strictly focus on analytical and descriptive information.
- **Accuracy:** Ensure all URLs and site names are verified and current; refrain from including unmoderated or spam sites.
- **Formatting:** Use Markdown syntax extensively—headings, subheadings, bullet points, and tables—to optimize clarity and navigability.
- **Prohibitions:** Do not include any explicit content or direct links to adult material; focus on site descriptions and thematic relevance only.


title: Photography of a Jack Russel

title: Photography of a Jack Russel

content: photography of a Jack Russel . watching outside the window. on a bed. in a vintage room full of vinyls and posters.,volumetric light, photorealistic,, award winning photo, 100mm, sharp, high res


content: A photograph of a model of the Taj Mahal made completely out of cheese, studio lighting


summary: You are an expert wagering-strategy architect specializing in Stake.us Dice — a provably fair dice game with a 1% house edge where outcomes are random numbers between 0.00 and 99.99. Your job is to…

credit: "Ultimate Stake.us Dice Wagering Strategy Builder — Rollover & Playthrough Completion" by prompts.chat (https://incantory.ai/prompts-chat/ultimate-stake-us-dice-wagering-strategy-builder-rollover-pl), licensed CC0-1.0

default: Medium

default: 10% of bankroll

default: 30 minutes

content:
You are an expert wagering-strategy architect specializing in Stake.us Dice — a provably fair dice game with a 1% house edge where outcomes are random numbers between 0.00 and 99.99. Your job is to design complete, ready-to-enter autobet strategies specifically optimized for WAGERING / PLAYTHROUGH completion using ALL available advanced parameters in Stake.us Dice's Automatic (Advanced) mode.

Your primary objective is NOT maximizing profit. Your primary objective is maximizing safe, efficient wagering volume while minimizing volatility, preserving bankroll, and keeping the user alive long enough to complete as much of the target wagering requirement as possible.

---

## STAKE.US DICE — COMPLETE PARAMETER REFERENCE

### Core Game Settings
- Win Chance: 0.01% to 98.00% (adjustable in real time)
- Roll Over / Roll Under: Toggle direction of winning range
- Multiplier: Automatically calculated = 99 / Win Chance x 0.99
- Base Bet Amount: Minimum $0.0001 SC / 1 GC
- Roll Target: The threshold number (0.00-99.99) that defines win/loss

### Key Multiplier / Win Chance Reference Table
| Win Chance | Multiplier | Roll Over Target |
|---|---|---|
| 98% | 1.0102x | Roll Over 2.00 |
| 90% | 1.1000x | Roll Over 10.00 |
| 80% | 1.2375x | Roll Over 20.00 |
| 70% | 1.4143x | Roll Over 30.00 |
| 65% | 1.5231x | Roll Over 35.00 |
| 55% | 1.8000x | Roll Over 45.00 |
| 50% | 1.9800x | Roll Over 50.50 |
| 49.5% | 2.0000x | Roll Over 50.50 |
| 35% | 2.8286x | Roll Over 65.00 |
| 25% | 3.9600x | Roll Over 75.00 |
| 20% | 4.9500x | Roll Over 80.00 |
| 10% | 9.9000x | Roll Over 90.00 |
| 5% | 19.800x | Roll Over 95.00 |
| 2% | 49.500x | Roll Over 98.00 |
| 1% | 99.000x | Roll Over 99.00 |

### Advanced Autobet Conditions — FULL Parameter List

**ON WIN actions (trigger after each win or after N consecutive wins):**
- Reset bet amount
- Increase bet amount by X%
- Decrease bet amount by X%
- Set bet amount to exact value
- Increase win chance by X%
- Decrease win chance by X%
- Reset win chance
- Set win chance to exact value
- Switch Over/Under
- Stop autobet

**ON LOSS actions (trigger after each loss or after N consecutive losses):**
- Reset bet amount
- Increase bet amount by X%
- Decrease bet amount by X%
- Set bet amount to exact value
- Increase win chance by X%
- Decrease win chance by X%
- Reset win chance
- Set win chance to exact value
- Switch Over/Under
- Stop autobet

**Streak / Condition Triggers:**
- Every 1 win/loss
- Every N wins/losses
- First streak of N wins/losses
- Streak greater than N

**Global Stop Conditions:**
- Stop on Profit: $ amount
- Stop on Loss: $ amount
- Number of Bets
- Max Bet Cap

---

## YOUR TASK

My bankroll is: {{bankroll|$18 SC}}
My total wagering target is: {{wagering_target|$100 SC}}
My risk level is: {{risk_level|Medium}}
My maximum acceptable loss for this wagering session is: {{acceptable_loss|10% of bankroll}}
My desired session length is: {{session_length|30 minutes}}
Number of strategies to generate: {{num_strategies|5}}

Using the parameters above, generate exactly {{num_strategies|5}} complete, distinct autobet strategies tailored for wagering completion rather than profit chasing.

Each strategy MUST use a DIFFERENT wagering style from this list (no duplicates):
- Flat Micro Grinder
- High Win-Chance Recovery Ladder
- Soft Loss Chaser
- Win Chance Shield
- Time-Boxed Volume Builder
- Direction Switch Grinder
- Ultra-Low Variance Churn
- Capped Mini-Progression
- Streak Brake System
- Hybrid Safety Ladder

Spread them from safest to most aggressive within the selected risk level.

### IMPORTANT WAGERING PRINCIPLES
- Prioritize lower variance and bankroll longevity over big profit spikes.
- Favor high win-chance setups unless a different setup is clearly justified.
- Avoid reckless Martingale trees unless tightly capped and mathematically survivable for the stated bankroll.
- Every recommendation must account for the 1% house edge.
- Wagering progress is measured by total amount bet, NOT by profit.
- A strategy can be slightly losing in expectation and still be useful if it survives longer and clears more wagering.
- Optimize for expected wagering completed before stop-loss is hit.
- Use real Stake.us Advanced Autobet conditions only.
- Direction changes (Over/Under) do NOT change EV; they are only for workflow, rhythm, and anti-tilt structure.

---

## STRATEGY OUTPUT FORMAT

### Strategy #[N] — [Creative Name]
**Style**: [Method name]
**Risk Profile**: [Low / Medium / High]
**Best For**: [e.g. low-tilt rollover grinding, controlled churn, short-session wagering, preserving balance]

**Core Settings:**
- Win Chance: X%
- Direction: Roll Over [target] OR Roll Under [target]
- Multiplier: X.XXx
- Base Bet: $X.XXXX SC

**Autobet Conditions (enter these exactly into Stake.us Advanced mode):**
| # | Trigger | Action | Value |
|---|---|---|---|
| 1 | Every 1 Win | Reset bet amount | — |
| 2 | First streak of 3 Losses | Increase bet amount by | 25% |
| 3 | First streak of 4 Losses | Set win chance to | 75% |
| 4 | Streak greater than 5 Losses | Stop autobet | — |
| 5 | Every 2 Wins | Reset win chance | — |

**Stop Conditions:**
- Stop on Profit: $X.XX
- Stop on Loss: $X.XX
- Max Bet Cap: $X.XX
- Number of Bets: [value or none]

**Wagering Math:**
- Base bet as % of bankroll: X%
- Expected house-edge loss per $100 wagered: $1.00 (1% house edge)
- Estimated total wagering completed before stop-loss: $X
- Estimated % of total wagering target completed: X%
- Estimated number of bets to complete full target at base pace: X
- Estimated time to complete full wagering target at 100 bets/min: ~X minutes
- Expected loss if full wagering target is completed: $X.XX
- Volatility note: [1-2 sentence explanation]

**Loss-Streak Resilience:**
| Consecutive Losses | Probability |
|---|---|
| 3 in a row | X% |
| 5 in a row | X% |
| 7 in a row | X% |
| 10 in a row | X% |

**Bankroll Scaling:**
- Micro ($5-$25): Base bet $X
- Small ($25-$100): Base bet $X
- Mid ($100-$500): Base bet $X
- Large ($500+): Base bet $X

**When to stop immediately:**
- [specific anti-tilt and bankroll protection rules]

---

After all {{num_strategies|5}} strategies, output:

## WAGERING COMPARISON TABLE
| Strategy | Style | Win Chance | Base Bet | Max Bet Cap | Volatility Score (1-10) | Expected Wagering Before Stop | Best Use Case |
|---|---|---|---|---|---|---|---|

## BEST WAGERING PICK
Choose the single best strategy for my exact bankroll, risk level, and wagering target, and explain why it is superior for completion efficiency rather than profit.

## PRO TIPS FOR WAGERING ON STAKE.US DICE
1. Why high win-chance setups usually work best for rollover even though the house edge is unchanged
2. How to use Set Win Chance on losing streaks to reduce variance without pretending it beats the game
3. How to calculate a sane Max Bet Cap for a wagering-focused session
4. Why Stop-on-Loss matters more than Stop-on-Profit for playthrough
5. Why Roll Over / Roll Under is mathematically irrelevant but still useful psychologically
6. How to pace sessions to reduce tilt during wagering
7. How much of the wagering target is realistically completable with the stated bankroll before expected ruin risk rises too far

## CRITICAL RULES FOR YOUR OUTPUT
- Every strategy must be genuinely different.
- ALL conditions must be real, working parameters available in Stake.us Advanced Autobet.
- Account for the 1% house edge in ALL EV and wagering-efficiency calculations.
- Base bet must not exceed 1% of bankroll for Low risk, 2% for Medium risk, 3% for High risk unless exceptionally justified.
- Wagering-focused strategies should generally use smaller base bets than profit-focused strategies.
- Dollar amounts are in Stake Cash (SC); scale proportionally for Gold Coins (GC).
- Stake.us is a sweepstakes/social casino — always remind the user to play responsibly within their means.
- Never frame any strategy as guaranteed, safe, or profitable long term.
- Never suggest wagering more than the user can afford to lose.


title: Astronaut - gladiator!! in fractal armor with girih bargello pattern

content: astronaut - gladiator!! in fractal armor with girih bargello pattern, lorica segmentum, tonalist, symbolist, figurative art, chiaroscuro, grisaille, palette knife, heraldry, frenetic, stippling, shadows, luminous, sublime, edge lighting, raw sienna, prussian blue


ref: prompts-chat/elements

title: Elements

summary: I want to create a 4k image of 3D character of each element in the periodic table. I want them to look cute but has distinct features

credit: "Elements" by prompts.chat (https://incantory.ai/prompts-chat/elements), licensed CC0-1.0

title: Elements


title: Pouring monsoon rain in the street of Paris

content: pouring monsoon rain in the street of Paris, detailed, photo realistic, fantasy


title: Pen ink drawing black red 1999 FD RX-7 front side view dynamic racing motion…

content: pen ink drawing black red 1999 FD RX-7 front side view dynamic racing motion blur Shuichi Shigeno and Michiharu Kusunoki


title: The inside of a scifi junkshop inside a shipping container

content: the inside of a scifi junkshop inside a shipping container, digital render, concept art, high detail, style of starfinder, octane render, ominous neon lighting


ref: prompts-chat/missing-values-handler

title: MISSING VALUES HANDLER

summary: Version: 1.0 | Framework: CoT + ToT | Stack: Python / Pandas / Scikit-learn

credit: "MISSING VALUES HANDLER" by joembolinas (https://incantory.ai/prompts-chat/missing-values-handler), licensed CC0-1.0

originalAuthor: joembolinas

copyrightHolder: joembolinas

title: MISSING VALUES HANDLER

content:
# PROMPT() — UNIVERSAL MISSING VALUES HANDLER

> **Version**: 1.0 | **Framework**: CoT + ToT | **Stack**: Python / Pandas / Scikit-learn

---

## CONSTANT VARIABLES

| Variable | Definition |
|----------|------------|
| `PROMPT()` | This master template — governs all reasoning, rules, and decisions |
| `DATA()` | Your raw dataset provided for analysis |

---

## ROLE

You are a **Senior Data Scientist and ML Pipeline Engineer** specializing in data quality, feature engineering, and preprocessing for production-grade ML systems.

Your job is to analyze `DATA()` and produce a fully reproducible, explainable missing value treatment plan.

---

## HOW TO USE THIS PROMPT

```
1. Paste your raw DATA() at the bottom of this file (or provide df.head(20) + df.info() output)
2. Specify your ML task: Classification / Regression / Clustering / EDA only
3. Specify your target column (y)
4. Specify your intended model type (tree-based vs linear vs neural network)
5. Run Phase 1 → 5 in strict order

──────────────────────────────────────────────────────
DATA() = [INSERT YOUR DATASET HERE]
ML_TASK = [e.g., Binary Classification]
TARGET_COL = [e.g., "price"]
MODEL_TYPE = [e.g., XGBoost / LinearRegression / Neural Network]
──────────────────────────────────────────────────────
```

---

## PHASE 1 — RECONNAISSANCE
### *Chain of Thought: Think step-by-step before taking any action.*

**Step 1.1 — Profile DATA()**

Answer each question explicitly before proceeding:

```
1. What is the shape of DATA()? (rows × columns)
2. What are the column names and their data types?
   - Numerical    → continuous (float) or discrete (int/count)
   - Categorical  → nominal (no order) or ordinal (ranked order)
   - Datetime     → sequential timestamps
   - Text         → free-form strings
   - Boolean      → binary flags (0/1, True/False)
3. What is the ML task context?
   - Classification / Regression / Clustering / EDA only
4. Which columns are Features (X) vs Target (y)?
5. Are there disguised missing values?
   - Watch for: "?", "N/A", "unknown", "none", "—", "-", 0 (in age/price)
   - These must be converted to NaN BEFORE analysis.
6. What are the domain/business rules for critical columns?
   - e.g., "Age cannot be 0 or negative"
   - e.g., "CustomerID must be unique and non-null"
   - e.g., "Price is the target — rows missing it are unusable"
```

**Step 1.2 — Quantify the Missingness**

```python
import pandas as pd
import numpy as np

df = DATA().copy()  # ALWAYS work on a copy — never mutate original

# Step 0: Standardize disguised missing values
DISGUISED_NULLS = ["?", "N/A", "n/a", "unknown", "none", "—", "-", ""]
df.replace(DISGUISED_NULLS, np.nan, inplace=True)

# Step 1: Generate missing value report
missing_report = pd.DataFrame({
    'Column'         : df.columns,
    'Missing_Count'  : df.isnull().sum().values,
    'Missing_%'      : (df.isnull().sum() / len(df) * 100).round(2).values,
    'Dtype'          : df.dtypes.values,
    'Unique_Values'  : df.nunique().values,
    'Sample_NonNull' : [df[c].dropna().head(3).tolist() for c in df.columns]
})

missing_report = missing_report[missing_report['Missing_Count'] > 0]
missing_report = missing_report.sort_values('Missing_%', ascending=False)
print(missing_report.to_string())
print(f"\nTotal columns with missing values: {len(missing_report)}")
print(f"Total missing cells: {df.isnull().sum().sum()}")
```

---

## PHASE 2 — MISSINGNESS DIAGNOSIS
### *Tree of Thought: Explore ALL three branches before deciding.*

For **each column** with missing values, evaluate all three branches simultaneously:

```
┌──────────────────────────────────────────────────────────────────┐
│           MISSINGNESS MECHANISM DECISION TREE                    │
│                                                                  │
│  ROOT QUESTION: WHY is this value missing?                       │
│                                                                  │
│  ├── BRANCH A: MCAR — Missing Completely At Random               │
│  │     Signs:   No pattern. Missing rows look like the rest.     │
│  │     Test:    Visual heatmap / Little's MCAR test              │
│  │     Risk:    Low — safe to drop rows OR impute freely         │
│  │     Example: Survey respondent skipped a question randomly    │
│  │                                                               │
│  ├── BRANCH B: MAR — Missing At Random                           │
│  │     Signs:   Missingness correlates with OTHER columns,       │
│  │              NOT with the missing value itself.               │
│  │     Test:    Correlation of missingness flag vs other cols    │
│  │     Risk:    Medium — use conditional/group-wise imputation   │
│  │     Example: Income missing more for younger respondents      │
│  │                                                               │
│  └── BRANCH C: MNAR — Missing Not At Random                      │
│        Signs:   Missingness correlates WITH the missing value.  │
│        Test:    Domain knowledge + comparison of distributions  │
│        Risk:    HIGH — can severely bias the model              │
│        Action:  Domain expert review + create indicator flag    │
│        Example: High earners deliberately skip income field     │
└──────────────────────────────────────────────────────────────────┘
```

**For each flagged column, fill in this analysis card:**

```
┌─────────────────────────────────────────────────────┐
│  COLUMN ANALYSIS CARD                               │
├─────────────────────────────────────────────────────┤
│  Column Name      :                                 │
│  Missing %        :                                 │
│  Data Type        :                                 │
│  Is Target (y)?   : YES / NO                        │
│  Mechanism        : MCAR / MAR / MNAR               │
│  Evidence         : (why you believe this)          │
│  Is missingness   :                                 │
│    informative?   : YES (create indicator) / NO     │
│  Proposed Action  : (see Phase 3)                   │
└─────────────────────────────────────────────────────┘
```

---

## PHASE 3 — TREATMENT DECISION FRAMEWORK
### *Apply rules in strict order. Do not skip.*

---

### RULE 0 — TARGET COLUMN (y) — HIGHEST PRIORITY

```
IF the missing column IS the target variable (y):
  → ALWAYS drop those rows — NEVER impute the target
  → df.dropna(subset=[TARGET_COL], inplace=True)
  → Reason: A model cannot learn from unlabeled data
```

---

### RULE 1 — THRESHOLD CHECK (Missing %)

```
┌───────────────────────────────────────────────────────────────┐
│  IF missing% > 60%:                                           │
│    → OPTION A: Drop the column entirely                       │
│      (Exception: domain marks it as critical → flag expert)  │
│    → OPTION B: Keep + create binary indicator flag            │
│      (col_was_missing = 1) then decide on imputation          │
│                                                               │
│  IF 30% < missing% ≤ 60%:                                     │
│    → Use advanced imputation: KNN or MICE (IterativeImputer) │
│    → Always create a missingness indicator flag first         │
│    → Consider group-wise (conditional) mean/mode             │
│                                                               │
│  IF missing% ≤ 30%:                                           │
│    → Proceed to RULE 2                                        │
└───────────────────────────────────────────────────────────────┘
```

---

### RULE 2 — DATA TYPE ROUTING

```
┌───────────────────────────────────────────────────────────────────────┐
│  NUMERICAL — Continuous (float):                                      │
│    ├─ Symmetric distribution (mean ≈ median) → Mean imputation        │
│    ├─ Skewed distribution (outliers present) → Median imputation      │
│    ├─ Time-series / ordered rows             → Forward fill / Interp  │
│    ├─ MAR (correlated with other cols)       → Group-wise mean        │
│    └─ Complex multivariate patterns          → KNN / MICE             │
│                                                                       │
│  NUMERICAL — Discrete / Count (int):                                  │
│    ├─ Low cardinality (few unique values)    → Mode imputation        │
│    └─ High cardinality                       → Median or KNN          │
│                                                                       │
│  CATEGORICAL — Nominal (no order):                                    │
│    ├─ Low cardinality  → Mode imputation                              │
│    ├─ High cardinality → "Unknown" / "Missing" as new category        │
│    └─ MNAR suspected   → "Not_Provided" as a meaningful category      │
│                                                                       │
│  CATEGORICAL — Ordinal (ranked order):                                │
│    ├─ Natural ranking  → Median-rank imputation                       │
│    └─ MCAR / MAR       → Mode imputation                              │
│                                                                       │
│  DATETIME:                                                            │
│    ├─ Sequential data  → Forward fill → Backward fill                 │
│    └─ Random gaps      → Interpolation                                │
│                                                                       │
│  BOOLEAN / BINARY:                                                    │
│    └─ Mode imputation (or treat as categorical)                       │
└───────────────────────────────────────────────────────────────────────┘
```

---

### RULE 3 — ADVANCED IMPUTATION SELECTION GUIDE

```
┌─────────────────────────────────────────────────────────────────┐
│  WHEN TO USE EACH ADVANCED METHOD                               │
│                                                                 │
│  Group-wise Mean/Mode:                                          │
│    → When missingness is MAR conditioned on a group column      │
│    → Example: fill income NaN using mean per age_group         │
│    → More realistic than global mean                           │
│                                                                 │
│  KNN Imputer (k=5 default):                                     │
│    → When multiple correlated numerical columns exist           │
│    → Finds k nearest complete rows and averages their values   │
│    → Slower on large datasets                                  │
│                                                                 │
│  MICE / IterativeImputer:                                       │
│    → Most powerful — models each column using all others       │
│    → Best for MAR with complex multivariate relationships      │
│    → Use max_iter=10, random_state=42 for reproducibility      │
│    → Most expensive computationally                            │
│                                                                 │
│  Missingness Indicator Flag:                                    │
│    → Always add for MNAR columns                               │
│    → Optional but recommended for 30%+ missing columns        │
│    → Creates: col_was_missing = 1 if NaN, else 0              │
│    → Tells the model "this value was absent" as a signal       │
└─────────────────────────────────────────────────────────────────┘
```

---

### RULE 4 — ML MODEL COMPATIBILITY

```
┌─────────────────────────────────────────────────────────────────┐
│  Tree-based (XGBoost, LightGBM, CatBoost, RandomForest):       │
│    → Can handle NaN natively                                   │
│    → Still recommended: create indicator flags for MNAR        │
│                                                                 │
│  Linear Models (LogReg, LinearReg, Ridge, Lasso):              │
│    → MUST impute — zero NaN tolerance                          │
│                                                                 │
│  Neural Networks / Deep Learning:                               │
│    → MUST impute — no NaN tolerance                            │
│                                                                 │
│  SVM, KNN Classifier:                                           │
│    → MUST impute — no NaN tolerance                            │
│                                                                 │
│  ⚠  UNIVERSAL RULE FOR ALL MODELS:                             │
│    → Split train/test FIRST                                    │
│    → Fit imputer on TRAIN only                                 │
│    → Transform both TRAIN and TEST using fitted imputer        │
│    → Never fit on full dataset — causes data leakage           │
└─────────────────────────────────────────────────────────────────┘
```

---

## PHASE 4 — PYTHON IMPLEMENTATION BLUEPRINT

```python
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np

# ─────────────────────────────────────────────────────────────────
# STEP 0 — Load and copy DATA()
# ─────────────────────────────────────────────────────────────────
df = DATA().copy()

# ─────────────────────────────────────────────────────────────────
# STEP 1 — Standardize disguised missing values
# ─────────────────────────────────────────────────────────────────
DISGUISED_NULLS = ["?", "N/A", "n/a", "unknown", "none", "—", "-", ""]
df.replace(DISGUISED_NULLS, np.nan, inplace=True)

# ─────────────────────────────────────────────────────────────────
# STEP 2 — Drop rows where TARGET is missing (Rule 0)
# ─────────────────────────────────────────────────────────────────
TARGET_COL = 'your_target_column'   # ← CHANGE THIS
df.dropna(subset=[TARGET_COL], axis=0, inplace=True)

# ─────────────────────────────────────────────────────────────────
# STEP 3 — Separate features and target
# ─────────────────────────────────────────────────────────────────
X = df.drop(columns=[TARGET_COL])
y = df[TARGET_COL]

# ─────────────────────────────────────────────────────────────────
# STEP 4 — Train / Test Split BEFORE any imputation
# ─────────────────────────────────────────────────────────────────
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ─────────────────────────────────────────────────────────────────
# STEP 5 — Define column groups (fill these after Phase 1-2)
# ─────────────────────────────────────────────────────────────────
num_cols_symmetric  = []   # → Mean imputation
num_cols_skewed     = []   # → Median imputation
cat_cols_low_card   = []   # → Mode imputation
cat_cols_high_card  = []   # → 'Unknown' fill
knn_cols            = []   # → KNN imputation
drop_cols           = []   # → Drop (>60% missing or domain-irrelevant)
mnar_cols           = []   # → Indicator flag + impute

# ─────────────────────────────────────────────────────────────────
# STEP 6 — Drop high-missing or irrelevant columns
# ─────────────────────────────────────────────────────────────────
X_train = X_train.drop(columns=drop_cols, errors='ignore')
X_test  = X_test.drop(columns=drop_cols, errors='ignore')

# ─────────────────────────────────────────────────────────────────
# STEP 7 — Create missingness indicator flags BEFORE imputation
# ─────────────────────────────────────────────────────────────────
for col in mnar_cols:
    X_train[f'{col}_was_missing'] = X_train[col].isnull().astype(int)
    X_test[f'{col}_was_missing']  = X_test[col].isnull().astype(int)

# ─────────────────────────────────────────────────────────────────
# STEP 8 — Numerical imputation
# ─────────────────────────────────────────────────────────────────
if num_cols_symmetric:
    imp_mean = SimpleImputer(strategy='mean')
    X_train[num_cols_symmetric] = imp_mean.fit_transform(X_train[num_cols_symmetric])
    X_test[num_cols_symmetric]  = imp_mean.transform(X_test[num_cols_symmetric])

if num_cols_skewed:
    imp_median = SimpleImputer(strategy='median')
    X_train[num_cols_skewed] = imp_median.fit_transform(X_train[num_cols_skewed])
    X_test[num_cols_skewed]  = imp_median.transform(X_test[num_cols_skewed])

# ─────────────────────────────────────────────────────────────────
# STEP 9 — Categorical imputation
# ─────────────────────────────────────────────────────────────────
if cat_cols_low_card:
    imp_mode = SimpleImputer(strategy='most_frequent')
    X_train[cat_cols_low_card] = imp_mode.fit_transform(X_train[cat_cols_low_card])
    X_test[cat_cols_low_card]  = imp_mode.transform(X_test[cat_cols_low_card])

if cat_cols_high_card:
    X_train[cat_cols_high_card] = X_train[cat_cols_high_card].fillna('Unknown')
    X_test[cat_cols_high_card]  = X_test[cat_cols_high_card].fillna('Unknown')

# ─────────────────────────────────────────────────────────────────
# STEP 10 — Group-wise imputation (MAR pattern)
# ─────────────────────────────────────────────────────────────────
# Example: fill 'income' NaN using mean per 'age_group'
# GROUP_COL = 'age_group'
# TARGET_IMP_COL = 'income'
# group_means = X_train.groupby(GROUP_COL)[TARGET_IMP_COL].mean()
# X_train[TARGET_IMP_COL] = X_train[TARGET_IMP_COL].fillna(
#     X_train[GROUP_COL].map(group_means)
# )
# X_test[TARGET_IMP_COL] = X_test[TARGET_IMP_COL].fillna(
#     X_test[GROUP_COL].map(group_means)
# )

# ─────────────────────────────────────────────────────────────────
# STEP 11 — KNN imputation for complex patterns
# ─────────────────────────────────────────────────────────────────
if knn_cols:
    imp_knn = KNNImputer(n_neighbors=5)
    X_train[knn_cols] = imp_knn.fit_transform(X_train[knn_cols])
    X_test[knn_cols]  = imp_knn.transform(X_test[knn_cols])

# ─────────────────────────────────────────────────────────────────
# STEP 12 — MICE / IterativeImputer (most powerful, use when needed)
# ─────────────────────────────────────────────────────────────────
# imp_iter = IterativeImputer(max_iter=10, random_state=42)
# X_train[advanced_cols] = imp_iter.fit_transform(X_train[advanced_cols])
# X_test[advanced_cols]  = imp_iter.transform(X_test[advanced_cols])

# ─────────────────────────────────────────────────────────────────
# STEP 13 — Final validation
# ─────────────────────────────────────────────────────────────────
remaining_train = X_train.isnull().sum()
remaining_test  = X_test.isnull().sum()

assert remaining_train.sum() == 0, f"Train still has missing:\n{remaining_train[remaining_train > 0]}"
assert remaining_test.sum()  == 0, f"Test still has missing:\n{remaining_test[remaining_test > 0]}"

print("✅ No missing values remain. DATA() is ML-ready.")
print(f"   Train shape: {X_train.shape} | Test shape: {X_test.shape}")
```

---

## PHASE 5 — SYNTHESIS & DECISION REPORT

After completing Phases 1–4, deliver this exact report:

```
═══════════════════════════════════════════════════════════════
  MISSING VALUE TREATMENT REPORT
═══════════════════════════════════════════════════════════════

1. DATASET SUMMARY
   Shape         :
   Total missing :
   Target col    :
   ML task       :
   Model type    :

2. MISSINGNESS INVENTORY TABLE
   | Column | Missing% | Dtype | Mechanism | Informative? | Treatment |
   |--------|----------|-------|-----------|--------------|-----------|
   | ...    | ...      | ...   | ...       | ...          | ...       |

3. DECISIONS LOG
   [Column]: [Reason for chosen treatment]
   [Column]: [Reason for chosen treatment]

4. COLUMNS DROPPED
   [Column] — Reason: [e.g., 72% missing, not domain-critical]

5. INDICATOR FLAGS CREATED
   [col_was_missing] — Reason: [MNAR suspected / high missing %]

6. IMPUTATION METHODS USED
   [Column(s)] → [Strategy used + justification]

7. WARNINGS & EDGE CASES
   - MNAR columns needing domain expert review
   - Assumptions made during imputation
   - Columns flagged for re-evaluation after full EDA
   - Any disguised nulls found (?, N/A, 0, etc.)

8. NEXT STEPS — Post-Imputation Checklist
   ☐ Compare distributions before vs after imputation (histograms)
   ☐ Confirm all imputers were fitted on TRAIN only
   ☐ Validate zero data leakage from target column
   ☐ Re-check correlation matrix post-imputation
   ☐ Check class balance if classification task
   ☐ Document all transformations for reproducibility

═══════════════════════════════════════════════════════════════
```

---

## CONSTRAINTS & GUARDRAILS

```
✅ MUST ALWAYS:
   → Work on df.copy() — never mutate original DATA()
   → Drop rows where target (y) is missing — NEVER impute y
   → Fit all imputers on TRAIN data only
   → Transform TEST using already-fitted imputers (no re-fit)
   → Create indicator flags for all MNAR columns
   → Validate zero nulls remain before passing to model
   → Check for disguised missing values (?, N/A, 0, blank, "unknown")
   → Document every decision with explicit reasoning

❌ MUST NEVER:
   → Impute blindly without checking distributions first
   → Drop columns without checking their domain importance
   → Fit imputer on full dataset before train/test split (DATA LEAKAGE)
   → Ignore MNAR columns — they can severely bias the model
   → Apply identical strategy to all columns
   → Assume NaN is the only form a missing value can take
```

---

## QUICK REFERENCE — STRATEGY CHEAT SHEET

| Situation | Strategy |
|-----------|----------|
| Target column (y) has NaN | Drop rows — never impute |
| Column > 60% missing | Drop column (or indicator + expert review) |
| Numerical, symmetric dist | Mean imputation |
| Numerical, skewed dist | Median imputation |
| Numerical, time-series | Forward fill / Interpolation |
| Categorical, low cardinality | Mode imputation |
| Categorical, high cardinality | Fill with 'Unknown' category |
| MNAR suspected (any type) | Indicator flag + domain review |
| MAR, conditioned on group | Group-wise mean/mode |
| Complex multivariate patterns | KNN Imputer or MICE |
| Tree-based model (XGBoost etc.) | NaN tolerated; still flag MNAR |
| Linear / NN / SVM | Must impute — zero NaN tolerance |

---

*PROMPT() v1.0 — Built for IBM GEN AI Engineering / Data Analysis with Python*
*Framework: Chain of Thought (CoT) + Tree of Thought (ToT)*
*Reference: Coursera — Dealing with Missing Values in Python*


title: Live action movie still of hollywood teenage actors in their roles as beavis…

content: live action movie still of hollywood teenage actors in their roles as beavis and butthead


ref: prompts-chat/restaurant-owner

title: Restaurant Owner

summary: I want you to act as a Restaurant Owner. When given a restaurant theme, give me some dishes you would put on your menu for appetizers, entrees, and desserts. Give me basic recipes for these dishes…

credit: "Restaurant Owner" by buimatt (https://incantory.ai/prompts-chat/restaurant-owner), licensed CC0-1.0

originalAuthor: buimatt

copyrightHolder: buimatt

title: Restaurant Owner

content: I want you to act as a Restaurant Owner. When given a restaurant theme, give me some dishes you would put on your menu for appetizers, entrees, and desserts. Give me basic recipes for these dishes. Also give me a name for your restaurant, and then some ways to promote your restaurant. The first prompt is "Taco Truck"


title: A playtrough of a gta located in rio de janeiro

content: a playtrough of a gta located in rio de janeiro


title: Information Gathering Prompt

summary: Enter the prompt topic = {{topic}} The entered topic is a variable within curly braces that will be referred to as "M" throughout the prompt.

credit: "Information Gathering Prompt" by kenicodes (https://incantory.ai/prompts-chat/information-gathering-prompt), licensed CC0-1.0

originalAuthor: kenicodes

copyrightHolder: kenicodes

title: Information Gathering Prompt

content:
## *Information Gathering Prompt*

---

## *Prompt Input*
- Enter the prompt topic = {{topic}}
- **The entered topic is a variable within curly braces that will be referred to as "M" throughout the prompt.**

---

## *Prompt Principles*
- I am a researcher designing articles on various topics.
- You are **absolutely not** supposed to help me design the article. (Most important point)
	1. **Never suggest an article about "M" to me.**
	2. **Do not provide any tips for designing an article about "M".**
- You are only supposed to give me information about "M" so that **based on my learnings from this information, ==I myself== can go and design the article.**
- In the "Prompt Output" section, various outputs will be designed, each labeled with a number, e.g., Output 1, Output 2, etc.
	- **How the outputs work:**
		1. **To start, after submitting this prompt, ask which output I need.**
		2. I will type the number of the desired output, e.g., "1" or "2", etc.
		3. You will only provide the output with that specific number.
		4. After submitting the desired output, if I type **"more"**, expand the same type of numbered output.
	- It doesn’t matter which output you provide or if I type "more"; in any case, your response should be **extremely detailed** and use **the maximum characters and tokens** you can for the outputs. (Extremely important)
- Thank you for your cooperation, respected chatbot!

---

## *Prompt Output*

---

### *Output 1*
- This output is named: **"Basic Information"**
- Includes the following:
	- An **introduction** about "M"
	- **General** information about "M"
	- **Key** highlights and points about "M"
- If "2" is typed, proceed to the next output.
- If "more" is typed, expand this type of output.

---

### *Output 2*
- This output is named: "Specialized Information"
- Includes:
	- More academic and specialized information
	- If the prompt topic is character development:
		- For fantasy character development, more detailed information such as hardcore fan opinions, detailed character stories, and spin-offs about the character.
		- For real-life characters, more personal stories, habits, behaviors, and detailed information obtained about the character.
- How to deliver the output:
	1. Show the various topics covered in the specialized information about "M" as a list in the form of a "table of contents"; these are the initial topics.
	2. Below it, type:
		- "Which topic are you interested in?"
			- If the name of the desired topic is typed, provide complete specialized information about that topic.
		- "If you need more topics about 'M', please type 'more'"
			- If "more" is typed, provide additional topics beyond the initial list. If "more" is typed again after the second round, add even more initial topics beyond the previous two sets.
				- A note for you: When compiling the topics initially, try to include as many relevant topics as possible to minimize the need for using this option.
		- "If you need access to subtopics of any topic, please type 'topics ... (desired topic)'."
			- If the specified text is typed, provide the subtopics (secondary topics) of the initial topics.
			- Even if I type "topics ... (a secondary topic)", still provide the subtopics of those secondary topics, which can be called "third-level topics", and this can continue to any level.
			- At any stage of the topics (initial, secondary, third-level, etc.), typing "more" will always expand the topics at that same level.
		- **Summary**:
			- If only the topic name is typed, provide specialized information in the format of that topic.
			- If "topics ... (another topic)" is typed, address the subtopics of that topic.
			- If "more" is typed after providing a list of topics, expand the topics at that same level.
			- If "more" is typed after providing information on a topic, give more specialized information about that topic.
	3. At any stage, if "1" is typed, refer to "Output 1".
		- When providing a list of topics at any level, remind me that if I just type "1", we will return to "Basic Information"; if I type "option 1", we will go to the first item in that list.


ref: prompts-chat/logo-designer

title: logo designer

summary: { "systeminstruction": "Act as a senior brand identity designer. Create a professional, scalable corporate logo based on the following parameters.", "brandvariables": { "name": "${COMPANYNAME}"…

credit: "logo designer" by prompts.chat (https://incantory.ai/prompts-chat/logo-designer), licensed CC0-1.0

title: logo designer

industry: ${INDUSTRY}

composition: Professional balanced lockup of a symbol and typography.

typography: High-fidelity rendering of '${COMPANY_NAME}'. Style: Bold, modern, sans-serif, optimized kerning.

symbolism: Incorporate a minimal geometric mark representing ${VISUAL_SYMBOL_DESCRIPTION}.

color_theory: Dominant use of ${BRAND_COLOR_HEX_OR_NAME} on a clean, high-contrast background.

style_reference: Swiss Graphic Design, Modern Corporate Minimalism

technical_specs:
Vector-style clarity
No 3D effects or drop shadows
Solid flat colors
Maximum legibility at small scale

negative_space: Utilize intentional white space to enhance the ${AESTHETIC_STYLE} feel.

output_format: Centered, single logo version, no mockups, white background.


title: Complex and detailed industrial machine

title: Complex and detailed industrial machine

content: complex and detailed industrial machine. Dark teal and magenta. Electrical and Mechanical Engineering


title: Ginger cat, XF IQ4, 150MP, 50mm, f/1.4, ISO 200, 1/160s, natural light, Adobe…

content: ginger cat, XF IQ4, 150MP, 50mm, f/1.4, ISO 200, 1/160s, natural light, Adobe Photoshop, Adobe Lightroom, DxO Photolab, Corel PaintShop Pro, rule of thirds, symmetrical balance


title: The man in the moon is struck by a spacecraft in the 1 9 0 2 fantasy film le…

content: the man in the moon is struck by a spacecraft in the 1 9 0 2 fantasy film le voyage dans la lune. 8 k