shannonthinking

Break down complex problems into structured steps using Claude Shannon's methodology—define problems, model solutions, validate with proofs or experiments, and implement practical designs.

Instructions

A problem-solving tool inspired by Claude Shannon's systematic and iterative approach to complex problems.

This tool helps break down problems using Shannon's methodology of problem definition, mathematical modeling, validation, and practical implementation.

When to use this tool:

Complex system analysis
Information processing problems
Engineering design challenges
Problems requiring theoretical frameworks
Optimization problems
Systems requiring practical implementation
Problems that need iterative refinement
Cases where experimental validation complements theory

Key features:

Systematic progression through problem definition → constraints → modeling → validation → implementation
Support for revising earlier steps as understanding evolves
Ability to mark steps for re-examination with new information
Experimental validation alongside formal proofs
Explicit tracking of assumptions and dependencies
Confidence levels for each step
Rich feedback and validation results

Parameters explained:

thoughtType: Type of thinking step (PROBLEM_DEFINITION, CONSTRAINTS, MODEL, PROOF, IMPLEMENTATION)
uncertainty: Confidence level in the current thought (0-1)
dependencies: Which previous thoughts this builds upon
assumptions: Explicit listing of assumptions made
isRevision: Whether this revises an earlier thought
revisesThought: Which thought is being revised
recheckStep: For marking steps that need re-examination
proofElements: For formal validation steps
experimentalElements: For empirical validation
implementationNotes: For practical application steps

The tool supports an iterative approach:

Define the problem's fundamental elements (revisable as understanding grows)
Identify system constraints and limitations (can be rechecked with new information)
Develop mathematical/theoretical models
Validate through proofs and/or experimental testing
Design and test practical implementations

Each thought can build on, revise, or re-examine previous steps, creating a flexible yet rigorous problem-solving framework.

Input Schema

Name	Required	Description
`assumptions`	Yes	Explicit list of assumptions
`dependencies`	Yes	Thought numbers this builds upon
`experimentalElements`	No	Elements for experimental validation
`implementationNotes`	No	Notes for practical implementation steps
`isRevision`	No	Whether this thought revises an earlier one
`nextThoughtNeeded`	Yes	Whether another thought step is needed
`proofElements`	No	Elements required for formal proof steps
`recheckStep`	No	For marking steps that need re-examination
`revisesThought`	No	The thought number being revised
`thought`	Yes	Your current thinking step
`thoughtNumber`	Yes	Current thought number
`thoughtType`	Yes	Type of thinking step
`totalThoughts`	Yes	Estimated total thoughts needed
`uncertainty`	Yes	Confidence level (0-1)

Input Schema (JSON Schema)

{
  "properties": {
    "assumptions": {
      "description": "Explicit list of assumptions",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "dependencies": {
      "description": "Thought numbers this builds upon",
      "items": {
        "minimum": 1,
        "type": "integer"
      },
      "type": "array"
    },
    "experimentalElements": {
      "description": "Elements for experimental validation",
      "properties": {
        "confidence": {
          "description": "Confidence in the experimental results (0-1)",
          "maximum": 1,
          "minimum": 0,
          "type": "number"
        },
        "limitations": {
          "description": "Limitations of the experimental validation",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "results": {
          "description": "Results of the experiment",
          "type": "string"
        },
        "testDescription": {
          "description": "Description of the experimental test",
          "type": "string"
        }
      },
      "required": [
        "testDescription",
        "results",
        "confidence",
        "limitations"
      ],
      "type": "object"
    },
    "implementationNotes": {
      "description": "Notes for practical implementation steps",
      "properties": {
        "practicalConstraints": {
          "description": "List of practical limitations and constraints",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "proposedSolution": {
          "description": "Detailed implementation proposal",
          "type": "string"
        }
      },
      "required": [
        "practicalConstraints",
        "proposedSolution"
      ],
      "type": "object"
    },
    "isRevision": {
      "description": "Whether this thought revises an earlier one",
      "type": "boolean"
    },
    "nextThoughtNeeded": {
      "description": "Whether another thought step is needed",
      "type": "boolean"
    },
    "proofElements": {
      "description": "Elements required for formal proof steps",
      "properties": {
        "hypothesis": {
          "description": "The hypothesis being tested",
          "type": "string"
        },
        "validation": {
          "description": "How the hypothesis was validated",
          "type": "string"
        }
      },
      "required": [
        "hypothesis",
        "validation"
      ],
      "type": "object"
    },
    "recheckStep": {
      "description": "For marking steps that need re-examination",
      "properties": {
        "newInformation": {
          "description": "New information prompting the recheck",
          "type": "string"
        },
        "reason": {
          "description": "Why the step needs to be rechecked",
          "type": "string"
        },
        "stepToRecheck": {
          "description": "Which type of step needs re-examination",
          "enum": [
            "problem_definition",
            "constraints",
            "model",
            "proof",
            "implementation"
          ],
          "type": "string"
        }
      },
      "required": [
        "stepToRecheck",
        "reason"
      ],
      "type": "object"
    },
    "revisesThought": {
      "description": "The thought number being revised",
      "minimum": 1,
      "type": "integer"
    },
    "thought": {
      "description": "Your current thinking step",
      "type": "string"
    },
    "thoughtNumber": {
      "description": "Current thought number",
      "minimum": 1,
      "type": "integer"
    },
    "thoughtType": {
      "description": "Type of thinking step",
      "enum": [
        "problem_definition",
        "constraints",
        "model",
        "proof",
        "implementation"
      ],
      "type": "string"
    },
    "totalThoughts": {
      "description": "Estimated total thoughts needed",
      "minimum": 1,
      "type": "integer"
    },
    "uncertainty": {
      "description": "Confidence level (0-1)",
      "maximum": 1,
      "minimum": 0,
      "type": "number"
    }
  },
  "required": [
    "thought",
    "thoughtType",
    "thoughtNumber",
    "totalThoughts",
    "uncertainty",
    "dependencies",
    "assumptions",
    "nextThoughtNeeded"
  ],
  "type": "object"
}

Shannon Thinking MCP Server