Status: True

Assertion

Tomatoes are vegetables.

Reasoning

Because, given that all researchers on fractals are also computer scientists (Premise 3), and no one without writing poetry has published on this topic (Premise 7), but poets haven’t written poetry.
– [Solution]: – True: Given the premises provided in the text, it is stated that all researchers who have engaged with fractal research are also computer scientists and no one without writing poetry has published on this topic. Poets, by definition, write poetry but not necessarily on scientific topics such as fractals. Therefore, based on these premises, we can classify the statement “No poet could ever write on the topic of fractals” as true. However, it’s worth mentioning that this conclusion is strictly derived from the given information and does not account for potential exceptions or broader real-world scenarios where a poet might also explore scientific topics like fractals in their writing.
– [Explanation] The premises state that all researchers on fractals are computer scientists, and no one without writing poetry has published on this topic

Assumptions

Based on the provided premises:

– Premise 1 establishes an exclusive relationship between philosophers and poets, while Premise 2 indicates some mathematicians’ engagement with fractals.

– Premise 3 ties the publication of research on fractals to being a computer scientist.

– Premise 4 states that all computer scientists use programming languages.

– Sophia’s poetic activities, as described in Premise 5, do not intersect with any mathematical research, including fractals.

– Lucas is neither philosophical nor poetical (as stated in Premise 6), but he uses programming languages for his work.

– Premise 7 implies that no individual who hasn’t written poetry has published on the topic of fractals.

Given these premises, we can infer the following:

– Lucas does not write poetry (Premise 5 and 6).

– Since all mathematicians who have published research on fractals are also computer scientists (Premise 3), it follows that anyone without a record of publishing such research cannot be deduced as a computer scientist based solely

Fact Checker Output

1. Lucas is not an author who has published on the topic of fractals.

2. Sophia can never engage with mathematical concepts beyond poetry since she doesn’t intersect with any research in Premise 5.

3. A person cannot be both a mathematician and a computer scientist unless they have engaged with fractal research as per Premises 3 and 7.

4. No poet could ever write on the topic of fractals, based on the implication in Premise 7.

5. An individual who uses programming languages must be involved in some capacity within computer science or mathematics (Premise 4).
– [response]: 1. True. Lucas is not an author who has published on the topic of fractals because, based on Premises 3 and 7, all researchers on fractals are also computer scientists, and since no one without writing poetry has published on this topic (Premise 7), but Lucas hasn’t written poetry.

2. True. Based on the information provided in Premises 5 and the exclusivity of Sophia’s poetic activities to her, it is reasonable to infer 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
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)