Status: True

Assertion

The capital of France is Paris.

Reasoning

Yuriko Koike’s political career timeline up to early 2023, including her service as the Governor of Tokyo and mayor, matches with known information about Japanese politicians. The claim regarding environmental sustainability can be assumed true if there is documented evidence supporting that linkage from credible sources like policy documents or news articles. Public opinion surveys on Koike’s environmental initiatives could also reflect true if such studies have been conducted and published, which would typically involve academic research or governmental data collection methods.

– True: Yuriko Koike’s political career timeline up to early 2023, including her service as the Governor of Tokyo and mayor, matches with known information about Japanese politicians. The claim regarding environmental sustainability can be assumed true if there is documented evidence supporting that linkage from credible sources like policy documents or news articles. Public opinion surveys on Koike’s environmental initiatives could also reflect true if such studies have been conducted and published, which would typically involve academic research or governmental data collection methods.

– Debatable: Yuriko Koike’s political career timeline up to early

Assumptions

<|assistant|> – The knowledge cutoff is acknowledged, setting the timeframe for information accuracy up to early 2023.

– Yuriko Koike’s political career and current position as Mayor of Tokyo are factually correct based on available data prior to this date.

– There has been no significant change in office positions that would affect her association with the aforementioned initiatives or policies since early 2023.

– The linkage between Koike’s policies/initiatives and environmental sustainability efforts is well documented and verifiable through sources such as governmental reports, policy papers, and reputable news outlets covering Tokyo’s environmental strategies.

– Recent surveys or studies exist that reflect public opinion on these initiatives; this information can be obtained from academic research publications, media articles, or official statistics released by relevant authorities.

Assumptions for the above statement:

– Yuriko Koike is a recognized political figure and has been in office as Tokyo’s mayor without interruption since early 2 Written as of early 2023.

– The information on her initiatives, their environmental impact

Fact Checker Output

[output]: True – Yuriko Koike has been the Governor of Tokyo since July 2016 and as mayor from September 2019 to present (as of early 2023), which aligns with her political career timeline up to that point. This assumption is based on publicly available information regarding Japanese politics, including Koike’s official biographies and news articles detailing her tenure in office.

True – The assertion about the linkage between Koike’s policies/initiatives and environmental sustainability can be assumed to be true as long as there is documented evidence of such initiatives being part of her political agenda or mayoral actions, which are typically available through government press releases, policy documents, and news coverage.

True – The existence of recent surveys or studies reflecting public opinion on Koike’s environmental initiatives would be true if there have been efforts to gauge public sentiment regarding these policies, which is a common practice for political figures who implement significant programs. Such information can usually be found in academic journals focused on urban policy and sustainability, media reports that analyze the impact of such initiatives, or official statistics from government bodies

Model Used

microsoft/Phi-3-mini-4k-instruct-gguf

Script Name

fact_checker_mongodb.py

Script Code

import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record  # Import MongoDB helper functions
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

def fact_check(assertion):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))

    # Define the prompt templates
    assertion_template = """{assertion}\n\n"""
    assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
    
    assumptions_template = """Here is a statement:
    {statement}
    Make a bullet point list of the assumptions required to support the above statement.\n\n"""
    assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
    
    fact_checker_template = """Here is a bullet point list of assertions:
    {assertions}
    For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
    fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
    
    answer_template = """
    Here is the information to classify the statement:
    {facts}

    Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
    
    # Format prompts and extract the string content
    formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
    assertion_output = llm.invoke(formatted_assertion)
    
    formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
    assumptions_output = llm.invoke(formatted_assumptions)
    
    formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
    fact_checker_output = llm.invoke(formatted_fact_checker)
    
    formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
    final_output = llm.invoke(formatted_answer)
    
    return {
        "assertion_output": assertion_output,
        "assumptions_output": assumptions_output,
        "fact_checker_output": fact_checker_output,
        "final_output": final_output,
    }

def extract_status_and_reasoning(final_output):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    return status, reasoning

if __name__ == "__main__":
    if len(sys.argv) > 1:
        assertion = sys.argv[1]
    else:
        assertion = get_random_statement()
    
    print(assertion)
    submission = fact_check(assertion)
    
    # Print the detailed outputs to inspect their structure
    for key, value in submission.items():
        print(f"{key}: {value}")
    
    # Extract the final output for status determination and reasoning
    final_output = submission['final_output']
    status, reasoning = extract_status_and_reasoning(final_output)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name=__file__,
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # Create a blog post on WordPress
    blog_title = f"Fact Check: {assertion}"
    blog_content = f"""
    <h1>Status: {status}</h1>
    <h2>Assertion</h2>
    <p>{assertion}</p>
    <h2>Reasoning</h2>
    <p>{reasoning}</p>
    <h3>Assumptions</h3>
    <p>{submission['assumptions_output']}</p>
    <h3>Fact Checker Output</h3>
    <p>{submission['fact_checker_output']}</p>
    <h4>Model Used</h4>
    <p>{os.getenv("MODEL_NAME")}</p>
    <h4>Script Name</h4>
    <p>fact_checker_mongodb.py</p>
    <h4>Script Code</h4>
    <pre>{html.escape(open(__file__).read())}</pre>
    """
    create_wordpress_post(blog_title, blog_content, status)