Problem solving combined with a problem analysis framework and generative AI

Problem-solving framework

As described in ‘Algorithmic Thinking, Problem Partitioning and Problem Solving’, various systematic approaches to problem solving have been considered in order to solve problems efficiently and effectively. Some examples of these are: 1.

1. the PDCA cycle: an approach suitable for continuous improvement and improving accuracy by repeating the process.
– Plan: identifying problems and developing solutions.
– Do: implement the solution.
– Check: Evaluate the results of implementation.
– Act: Improve the solution and use it in the next step. 2. 5W1H: Identify the problem.

2. 5W1H: an approach that helps to analyse the problem from multiple perspectives
– Who.
– What
– When
– Where
– Why
– How.

3. KPT (Keep, Problem, Try): a framework focusing on reflection and improvement.
– Keep: what was good (what needs to be continued).
– Problem: what went wrong (what needs improvement).
– Try: what to try next time (what you want to try).

4. MECE (Mutually Exclusive, Collectively Exhaustive): an approach to structurally understanding a problem and efficiently deriving a solution.
– MECE (Mutually Exclusive, Collectively Exhaustive): an approach to organising problems ‘without omissions or duplications’.

5. logic tree: a useful approach for delving deeper into the essence of a problem.
– A method for breaking down problems and visualising cause-effect relationships and structures.

6. SWOT analysis: an approach that helps formulate strategies taking into account internal and external factors.
– Strengths
– Weaknesses
– Opportunities
– Threats.

7. 5 Why’s: a simple approach that focuses on the search for causes.
– A method of repeating ‘why’s’ five times in order to identify the root cause of a problem.

8. design thinking: an approach to creative problem-solving from the user’s perspective.
– Empathise
– Define the problem
– Ideate
– Prototyping
– Test 9.

9. gap analysis of current situation and goals: an approach suitable for goal-oriented problem solving.
– Analyses the gap between the current state and the state to be achieved, and considers measures to close the gap.

10. LEAN start-up: an effective approach for achieving results through repeated hypothesis testing in a short period of time.
– Build: build a minimal product based on the hypothesis.
– Measure: measure user response.
– Learn: revise the hypothesis based on the results.

These frameworks are effective when used differently or in combination, depending on the situation and the nature of the issue. Which framework is most suitable depends on the scale of the problem and the needs of the people involved.

Specific solution procedures combining the issue analysis framework with chatgpt

By combining ChatGPT with such an issue analysis framework, an AI-assisted issue resolution solution can be built. This solution enables efficient and deep insights to be gained by utilising the characteristics of generative AI in existing frameworks. An example of a concrete solution procedure is given below.

1. clarifying the problem
Objective: to define the problem to be solved concretely and clearly.
Procedure:
1. organise the current status of the problem: provide the ChatGPT with brief background information on the current issue.
– E.g. ‘Please organise why process X is not efficient in our project.’
2. fleshing out the problem: consult the ChatGPT on how to define and prioritise the specific problems.
– E.g. ‘Please categorise the following issues and prioritise them based on urgency and importance.’

2 Root Cause Analysis
Objective: To explore the causes of the problem.
Procedure:
1. 5 Whys (Why-Why Analysis):
– Have ChatGPT generate questions to explore the ‘cause behind the problem’.
– Example: ‘Generate questions to drill down into why process X is inefficient.’
2. visualising causality:
– Have ChatGPT support the creation of causality diagrams (e.g. fishbone diagrams).
– E.g. ‘Please categorise the categories of causes that are causing this problem.’

3. solution brainstorming
Objective: To extensively consider solutions.
Procedure:
1. idea generation: ‘What is the best way to solve this problem?
– Have ChatGPT make an ‘exhaustive list of possible solutions’.
– E.g. ‘Please suggest 10 ways to make process X more efficient.’
2. define evaluation criteria for solutions:
– Have ChatGPT develop ‘evaluation criteria’ and a ‘decision matrix’.
– E.g. ‘Create a table to evaluate solutions based on cost, feasibility and impact.’

4. solution selection (Decision Making)
Objective: To select the best solution.
Procedure:
1. Multi-Criteria Decision Analysis:
– Ask ChatGPT to ‘compare the advantages and disadvantages of each solution’.
– Example: ‘Compare the following solutions in terms of impact and feasibility and choose the most effective one.’
2. simulation and hypothesis testing:
– Ask ChatGPT to construct a ‘hypothetical scenario’ and test its feasibility.
– E.g. ‘Please indicate the risks and expected consequences of adopting solution A.’

5. develop an implementation plan
Objective: to develop a plan to realise the solution.
Procedure:
1. action plan development:
– Have ChatGPT generate a ‘step-by-step action plan’.
– Example: ‘Create a detailed task and schedule for implementing Solution A.’
2. risk management:
– Have ChatGPT generate a list of ‘Potential risks and possible responses’.
– E.g. ‘Please anticipate the risks associated with this plan and suggest mitigation measures.’

6. implementation and monitoring
Objective: to implement the solution and monitor progress.
Procedure:
1. create a monitoring framework:
– Have ChatGPT set up ‘KPIs to measure progress’.
– E.g. ‘Please suggest indicators to measure the success of process improvements.’
2. regular reviews:
– Have ChatGPT suggest ‘frequency and content of reviews’.
– E.g.: ‘Develop a list of questions to assess improvement progress.’

7. reflection and next steps
Objective: to learn and consider next steps.
Procedure:
1. reflection on the results:
– Have ChatGPT generate ‘Reflection questions on the effectiveness of the solution’.
– E.g. ‘Please summarise what you have learnt from this project.’
2. continuous improvement:
– Have ChatGPT identify ‘next challenges and areas for improvement’.
– E.g. ‘Based on this improvement process, please suggest ways to further improve efficiency.’

Examples of specific system configurations

The structure of the above steps in a concrete system is shown below. The system covers the overall process of analysing issues from user input, proposing solutions and supporting progress management and reflection.

1. user interface (UI)
– Purpose: Interface for the user to enter issues and check the results.
– E.g.: issue entry form on a web browser, progress check on a mobile app. 2.

2. input processing layer
– Function: collects user-provided issue and background information. Supports voice input and document uploading if required.
– Implementation: correction of ambiguous input using Natural Language Processing (NLP).

3. issue analysis module
– Function: utilises ChatGPT to categorise and organise issues and analyse root causes.
– Implementation: uses ChatGPT API to support Why analysis and fishbone diagram generation, and if required, links to UI for visualising cause-effect relationships.

4. solution suggestion module:
– Function: generates multiple solutions and suggests priorities based on evaluation criteria.
– Implementation: brainstorming using ChatGPT, incorporating Multi-Criteria Decision Analysis tool.

5. implementation planning module
– Function: breaks down solutions into concrete tasks and creates an implementation plan. Also supports risk management.
– Implementation: schedule generation algorithms (e.g. Gantt chart display), database of risks and response measures.

6. monitoring and management module
– Function: manages progress during execution and measures target achievement with KPIs.
– Implementation: visualisation of progress on dashboards, alert function (e.g. Slack, email notifications).

7. look back and improvement module
– Function: supports project review and identifies next improvement ideas.
– Implementation: automatic report generation, suggestions for next issues using ChatGPT.

Technology stack.
– Front-end: React, Vue.js, etc.
– Backend: Python (Flask/Django), Node.js.
– AI API: OpenAI ChatGPT API.
– Databases: PostgreSQL, MongoDB.
– Visualisation tools: D3.js, Chart.js.
– Notification systems: Slack API, Twilio.

implementation example

<Issue analysis module>

Implementation structure

1. Front-end (UI)
   • A form on which users can enter causes and a canvas on which they can interactively edit fishbone diagrams.
   • Visualisation libraries such as D3.js and Chart.js for displaying cause-and-effect relationships.
2. Backend (API calls)
   • Call the ChatGPT API to deep dive into Why analysis based on user input.
   • Processes ChatGPT API responses and generates data for visualisation.
3. Data model
   • User input is managed in a tree structure (in the form of nodes and edges).
   • Input data is held in JSON format.
4. Visualisation engine
   • Uses D3.js or similar to draw fishbone diagrams and cause-and-effect graphs.

Example implementation: The following is an example of code to support Why analysis and fishbone diagram generation.

1. front end (HTML + JavaScript)

<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Why analysis and fishbone diagram generation</title>
<script src="https://d3js.org/d3.v7.min.js"></script>
<style>
#chart {
width: 100%;
height: 500px;
border: 1px solid #ccc;
}
</style>
</head>
<body>
<h1>Why分析ツール</h1>
<textarea id="user-input" rows="4" cols="50" placeholder="Please enter the problem"></textarea>
<button id="analyze-button">Perform a Why analysis.</button>
<div id="chart"></div>

<script>
const analyzeButton = document.getElementById('analyze-button');
analyzeButton.addEventListener('click', async () => {
const userInput = document.getElementById('user-input').value;
const response = await fetch('/analyze', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ input: userInput })
});
const result = await response.json();

// Drawing fishbone diagrams in D3.js
const chart = d3.select('#chart');
chart.selectAll('*').remove();
const svg = chart.append('svg').attr('width', 800).attr('height', 500);
drawFishbone(svg, result);
});

function drawFishbone(svg, data) {
// Example of drawing a simple fishbone diagram.
svg.append('text').text(data.problem).attr('x', 400).attr('y', 50).attr('text-anchor', 'middle');
data.reasons.forEach((reason, index) => {
svg.append('line')
.attr('x1', 400).attr('y1', 100 + index * 50)
.attr('x2', 200).attr('y2', 100 + index * 50)
.attr('stroke', 'black');
svg.append('text').text(reason).attr('x', 180).attr('y', 100 + index * 50).attr('text-anchor', 'end');
});
}
</script>
</body>
</html>

2. back-end (Python + Flask)

from flask import Flask, request, jsonify
import openai

app = Flask(__name__)

openai.api_key = "YOUR_OPENAI_API_KEY"

@app.route('/analyze', methods=['POST'])
def analyze():
    data = request.json
    user_input = data.get('input', '')

    # ChatGPT API calls
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant for root cause analysis."},
            {"role": "user", "content": f"問題点: {user_input}. Do a Why analysis and list the causes."}
        ]
    )
    answer = response['choices'][0]['message']['content']

    # Conversion to simple data structures
    reasons = [line for line in answer.split('n') if line.startswith('Reason')]
    result = {"problem": user_input, "reasons": reasons}

    return jsonify(result)

if __name__ == '__main__':
    app.run(debug=True)

3. example of JSON data

{
  "problem": "Low customer satisfaction.",
  "reasons": [
    "Reason 1: Slow support response",
    "Reason 2: Low product quality",
    "Reason 3: Website not user-friendly enough"
  ]
}

Execution steps.

1. Set the ChatGPT API key.
2. Run Python script to start Flask server.
3. Open the front end in a browser and enter the problem.
4. Click on ‘Run Why Analysis’ to visualise the analysis results.

Proposed extensions

• Real-time editing: drag-and-drop editing of fishbone diagrams.
• Causal strength analysis: add an impact score to each cause.
• History storage: save and re-use the user’s analysis data.

<Solution suggestion module>

A concrete implementation of a tool combining brainstorming and Multi-Criteria Decision Analysis (MCDA) using ChatGPT is shown below. The tool works through the following processes

1. Brainstorming: using ChatGPT to generate solutions and ideas.
2. Criteria setting: the user inputs the evaluation criteria and their weights.
3. Scoring: ChatGPT or the user scores the ideas on each criterion.
4. Multi-criteria evaluation: an overall score is calculated for each idea and a ranking is displayed.

Example implementations

1. front end (HTML + JavaScript)

<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Brainstorming & MCDA tools</title>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<style>
#output {
margin-top: 20px;
}
</style>
</head>
<body>
<h1>Brainstorming & MCDA tools</h1>

<h2>1. Enter the question.</h2>
<textarea id="problem-input" rows="4" cols="50" placeholder="Enter the problem you want to solve"></textarea>
<button id="generate-ideas">Generating ideas</button>

<h2>2. Set evaluation criteria and weights.</h2>
<div id="criteria">
<div>
<label>Criterion 1.: <input type="text" id="criterion-1" value="cost" /></label>
<label>weight: <input type="number" id="weight-1" value="1" /></label>
</div>
<div>
<label>Criterion 2.: <input type="text" id="criterion-2" value="effect" /></label>
<label>weight: <input type="number" id="weight-2" value="2" /></label>
</div>
</div>

<h2>3. result</h2>
<div id="output"></div>

<script>
document.getElementById('generate-ideas').addEventListener('click', async () => {
const problem = document.getElementById('problem-input').value;
const response = await fetch('/generate-ideas', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ problem })
});
const ideas = await response.json();

// for display
const output = document.getElementById('output');
output.innerHTML = `<h3>Generated ideas.:</h3><ul>${ideas.map(idea => `<li>${idea}</li>`).join('')}</ul>`;

// Processing of MCDA results.
const criteria = [
{ name: document.getElementById('criterion-1').value, weight: parseFloat(document.getElementById('weight-1').value) },
{ name: document.getElementById('criterion-2').value, weight: parseFloat(document.getElementById('weight-2').value) }
];

const responseScores = await fetch('/evaluate-ideas', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ ideas, criteria })
});
const scores = await responseScores.json();

// MCDA score display
output.innerHTML += `<h3>Assessment Results:</h3><ul>${scores.map(score => `<li>${score.idea}: ${score.totalScore}</li>`).join('')}</ul>`;
});
</script>
</body>
</html>

2. back-end (Python + Flask)

from flask import Flask, request, jsonify
import openai

app = Flask(__name__)
openai.api_key = "YOUR_OPENAI_API_KEY"

@app.route('/generate-ideas', methods=['POST'])
def generate_ideas():
    data = request.json
    problem = data.get('problem', '')

    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful brainstorming assistant."},
            {"role": "user", "content": f"Generate some ideas to solve the following problems: {problem}"}
        ]
    )
    ideas = response['choices'][0]['message']['content'].split('n')
    return jsonify(ideas)

@app.route('/evaluate-ideas', methods=['POST'])
def evaluate_ideas():
    data = request.json
    ideas = data.get('ideas', [])
    criteria = data.get('criteria', [])

    scores = []
    for idea in ideas:
        idea_scores = {}
        total_score = 0
        for criterion in criteria:
            weight = criterion.get('weight', 1)
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a decision analysis assistant."},
                    {"role": "user", "content": f"Idea: Please rate {idea} according to the following criteria: {criterion['name']}"}
                ]
            )
            score = int(response['choices'][0]['message']['content'].strip())
            idea_scores[criterion['name']] = score
            total_score += score * weight
        scores.append({'idea': idea, 'scores': idea_scores, 'totalScore': total_score})

    return jsonify(scores)

if __name__ == '__main__':
    app.run(debug=True)

Function description.

1. Idea generation:
   • User enters a problem on the front-end.
   • ChatGPT API generates relevant solutions.
2. Evaluation criteria setting:
   • User sets evaluation criteria and weights (e.g. cost, effectiveness).
3. Scoring:
   • ChatGPT returns a score for each criterion.
   • The front-end calculates an overall score for each idea and displays the ranking.
4. Visualisation.
   Visual comparison by graphing the results using e.g. Chart.js.

Proposed extensions

• Data storage: save evaluation results to a database for re-use.
• Collaboration: allows team members to evaluate ideas together.
• Automatic adjustment: dynamically adjust weights based on user feedback.

reference book

Reference books relevant to the design of systems using issue analysis frameworks and AI (in particular ChatGPT) are described below.

Related to problem analysis and system design
‘Design Thinking for Strategic Innovation’ by Idris Mootee.
Describes methods for using design thinking to analyse problems and find innovative solutions.
‘System Analysis and Design’ by Alan Dennis, Barbara Haley Wixom, and Roberta M. Roth
An introduction to the basic processes and frameworks of systems analysis and design.
‘Thinking in Systems: A Primer’ by Donella H. Meadows
This book provides the fundamentals of systems thinking and how to analyse issues holistically.

Books specialising in AI and ChatGPT applications.
‘Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow’ by Aurélien Géron
Describes a practical approach to designing machine learning systems, including the basics of understanding models such as GPT.
‘Building Machine Learning Powered Applications’ by Emmanuel Ameisen
Provides a step-by-step process for designing and implementing AI-powered applications.
‘Generative Deep Learning: teaching Machines to Paint, Write, Compose, and Play’ by David Foster
Explains generative models such as GPT from both a theoretical and practical perspective.
‘GPT-3: The Ultimate Guide to Building NLP Applications with OpenAI’s GPT-3 API’ by Nathan Hunter
A guide dedicated to how to develop applications utilising OpenAI’s GPT-3 API.
‘AI and Machine Learning for Coders’ by Laurence Moroney
A practical guide for engineers interested in developing solutions using AI technologies.

Problem-solving frameworks
‘The Lean Startup: How Today’s Entrepreneurs Use Continuous Innovation to Create Radically Successful Businesses’ by Eric Ries.
Explains the Lean Startup methodology, which links problem solving and innovation.
‘The Goal: A Process of Ongoing Improvement’ by Eliyahu M. Goldratt
A book in story form that teaches the theory of problem solving by looking at problems as a process.
‘Problem Solving 101: A Simple Book for Smart People’ by Ken Watanabe
A book for beginners that teaches the basics of problem solving using analysis and frameworks.

Visualisation and UI/UX design
‘The Visual Display of Quantitative Information’ by Edward R. Tufte
Describes methodologies for visualising data and communicating analytical results effectively.
‘Don’t Make Me Think: A Common Sense Approach to Web Usability’ by Steve Krug
Learn the basic principles of intuitive UI/UX design.
‘Storytelling with Data: A Data Visualisation Guide for Business Professionals’ by Cole Nussbaumer Knaflic
A practical book that teaches you how to create compelling stories with data.