Status: True

Assertion

Humans evolved from modern apes.

Reasoning

[Explanation]

The classification of the statement as true is supported by the context given in the fact-checking process output. Each point made within that output aligns with reasonable assumptions about closed systems and statistical principles without requiring specific evidence for this particular system, making them generally valid based on general knowledge related to these topics. Here’s a breakdown of each bullet point:

1. True: Various components or variables are present in a closed system by definition, which aligns with the understanding that “closed systems” typically contain interrelated elements within their boundaries. This assumption is reasonable without specific contextual information from the text.
2. True: Multiple possible values or states for each variable is characteristic of many complex systems and doesn’t necessitate unique evidence in this case, as it aligns with general knowledge about variables and their potential behaviors.
3. True: The principle that correlation does not necessarily imply causation is well-est

Assumptions

– response: – The existence of six distinct variables (A, B, C, D, E, and F) within the system.
– Each variable can have multiple possible values or states in this closed system.
– A correlation implies a statistical relationship between two variables where changes in one are associated with changes in another.
– Correlation does not necessarily imply causation; it merely indicates that there is some form of association.
– The correlations mentioned (A and B, as well as potentially others) have been identified through analysis or observation within this closed system.
– There is no external influence affecting the relationships between these variables; they are solely due to interactions within the closed system itself.
– The statistical methods used to determine correlation have been properly applied to ensure accurate results.
– Data for all potential pairs of correlations (A with B, A with C, A with D, etc.) has been collected or can be theoretically considered in this context.
– There are no hidden variables that influence the observed correlations but are not accounted for within the system under discussion.
– The relationships among these six variables remain consistent and unaltered over time; any changes would need to be explicitly stated as part of

Fact Checker Output

<|assistant|> – True: The existence of six distinct variables (A, B, C, D, E, and F) within the system is a clear assertion that can be verified by examining data or documentation regarding the closed system in question.
– True: Variables having multiple possible values or states is common in many systems and doesn’t require specific evidence to assume it could happen in this context as well.
– True: The statement about correlation not implying causation is a widely accepted principle in statistics, making it reasonable to consider this assumption valid without direct evidence for the closed system.
– True: Acknowledging that correlations have been identified through analysis or observation within the system implies there’s some level of methodology applied, even if specific details aren’t provided.
– True: Stating no external influence affecting relationships is reasonable when discussing a “closed” system; however, without explicit verification, it remains an assumption rather than proven fact.
– True: Assuming statistical methods have been properly applied is logical in the context of analyzing data for correlations but would require evidence to be fully substantiated as true.
– True: The assertion that there are no hidden variables affecting observed correlations is a

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)