Status: True

Assertion

The Eiffel Tower is located in Paris.

Results

Answer: Debatable

<|assistant|> Debatable. While it is true that for any statement to hold value there must be clarity around the context and relevant variables should generally be considered, these principles can vary in their application depending on specific situations, subject matter expertise of involved parties, and practical constraints such as data availability. Therefore, while these assumptions are important and often applicable, their truthfulness may not always directly support a statement without considering additional factors that could influence the outcome.

For example, if there is ambiguity in the context or unrecognized variables, it might still be possible for a statement to hold true or false. Additionally, some situations require specialized knowledge, and assumptions about defining context or including all relevant variables may not apply uniformly across different fields and scenarios. As such, while these principles are generally valuable guidelines, their ability to support any given statement can depend on the specifics of the situation at hand.

Assumptions

# Answer
To support an unspecified statement, one might need to consider several underlying assumptions. Here’s a bullet point list that could represent such foundational premises:

– The context or situation being referred to is well defined and understood by all parties involved.
– All relevant variables are identified and considered in the analysis.
– There is accessibility to accurate data for informed decision-making.
– Assumptions about causality between elements within the statement hold true without contradiction.
– The entities, processes, or behaviors described in the statement operate under normal conditions with no significant anomalies affecting outcomes.
– Any potential biases or perspectives influencing interpretation are acknowledged and minimized to ensure objectivity.
– There is a mutual understanding of the terminology and concepts used within the statement among all stakeholders.
– Ethical considerations, including consent and privacy where applicable, are respected in any actions resulting from or based on the statement’s implications.

These assumptions provide an essential framework for evaluating the validity and applicability of a particular statement within its intended context.

Fact Checker Output

support: Determining the truth value of these assumptions requires specific knowledge about the unspecified statement they are meant to support. However, I can provide an analysis based on general principles that apply across various scenarios. Here’s an evaluation of each assumption and a rationale for why it might generally be considered true or false in supporting statements:

1. The context or situation being referred to is well defined and understood by all parties involved.
– Generally True: For any statement to hold value, there must be clarity around the context in which it operates. However, this can vary depending on the complexity of the topic and stakeholders’ expertise. In most cases, defining and understanding the situation is essential for meaningful discussions.

2. All relevant variables are identified and considered in the analysis.
– Generally True: An accurate assessment usually depends on identifying and considering all significant factors that could influence outcomes. This principle applies broadly across various domains but might be challenging to achieve due to complexity or lack of knowledge about certain elements.
e.g., Economic models strive to include as many relevant variables as possible, although there are always constraints in terms of data availability and

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
}

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)

    # 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:
    - True
    - False
    - Debatable
    """
    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(final_output):
    final_output = final_output.lower().strip()
    if "true" in final_output:
        return "True"
    elif "false" in final_output:
        return "False"
    elif "debatable" in final_output:
        return "Debatable"
    else:
        return "Unknown"

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
    final_output = submission['final_output']
    
    # Determine the status based on the final output text
    status = extract_status(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>{final_output}</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)