Status: True

Assertion

Capitalism is the best economic system.

Results

The effectiveness and benefits of capitalism can indeed be measured objectively through economic indicators such as GDP growth, innovation rates, and quality of life improvements for citizens. These metrics provide quantifiable data that reflect the performance of a capitalist economy. Additionally, competition between businesses generally leads to better products/services for consumers, consumer choice drives product development, individual effort can influence success within capitalism, and the system has some level of flexibility in adapting to changing economic circumstances. However, it’s important to note that these statements may have exceptions or limitations as explained below.
– False: [Explanation] – There is no evidence presented here to suggest any falsehood about capitalism.
– Debatable: [Explanation] – While there are many aspects of the statement that can be generally agreed upon, some nuances and exceptions exist which could lead to differing opinions on their absolute nature. For example: Competition between businesses may not always lead to positive outcomes if unregulated; success in capitalism is influenced by various factors beyond individual effort, such as socioeconomic background; the flexibility of capitalism can vary depending on specific circumstances or external interventions.

Assumptions

<|assistant|> – The effectiveness and benefits of capitalism can be measured objectively through economic indicators such as GDP growth, innovation rates, and quality of life improvements for citizens.
– Competition between businesses is inherently beneficial to consumers and leads to better products/services without causing negative consequences like monopolies or market manipulation.
– The linkage between individual effort and success in capitalism holds true; hard work and innovation are rewarded with higher financial rewards, leading to overall improvements in living standards.
– Consumer choice is the primary driver of product and service development in a capitalist system, meaning that consumer demand accurately reflects what goods/services should be produced and improved upon.
– Capitalism’s flexibility allows it to adapt quickly to changing economic circumstances without causing significant disruptions or negative impacts on society as a whole.
– The existence of regulations within capitalist systems can help mitigate potential drawbacks, such as monopolies or environmental harm, ensuring the system remains effective and beneficial for all.
– Capitalism is compatible with social welfrances to address inequalities that may arise from individual success incentives, providing a safety net

Fact Checker Output

<|assistant|> – True: The effectiveness and benefits of capitalism can indeed be measured objectively through economic indicators such as GDP growth, innovation rates, and quality of life improvements for citizens. These metrics provide quantifiable data that reflect the performance of a capitalist economy.
– Mostly true with exceptions: Competition between businesses is generally beneficial to consumers, leading to better products/services. However, this statement doesn’t account for cases where competition may lead to unethical practices or monopolistic behaviors if not properly regulated.
– True: The linkage between individual effort and success in capitalism holds true to an extent; however, it is not the only factor influencing success. Other factors such as socioeconomic background, access to education, and systemic issues can affect one’s ability to succeed within a capitalist framework.
– True: Consumer choice is indeed a significant driver of product and service development in a capitalist system. Companies strive to meet consumer demands by developing new products or improving existing ones.
– Mostly true with exceptions: Capitalism does have flexibility, which can help it adapt quickly to changing economic circumstances. However, some argue that

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
import html

# Load environment variables from .env file
load_dotenv()

# Define category IDs
CATEGORY_IDS = {
    "True": 2,
    "False": 3,
    "Debatable": 4,
    "Unknown": 6
}

def create_wordpress_post(title, content, category):
    data = {
        "title": title,
        "content": content,
        "status": "publish",
        "categories": [CATEGORY_IDS[category]]
    }

    response = requests.post(
        os.getenv("WORDPRESS_POSTS_URL"),
        json=data,
        auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
    )

    if response.status_code == 201:
        print("Blog post created successfully.")
    else:
        print(f"Failed to create blog post: {response.status_code} - {response.text}")

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):
    final_output = final_output.strip()
    if "True:" in final_output:
        status_start = final_output.find("True:")
        status = "True"
    elif "False:" in final_output:
        status_start = final_output.find("False:")
        status = "False"
    elif "Debatable:" in final_output:
        status_start = final_output.find("Debatable:")
        status = "Debatable"
    else:
        return "Unknown", final_output

    reasoning = final_output[status_start + len(status) + 1:].strip()
    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)
    
    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name="fact_checker_mongodb.py",
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    print(final_output)
    
    # 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>Results</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)