Status: False

Assertion

Remote work is less productive than working in an office.

Reasoning

The statement oversimplifies complex issues related to hunger, genetic engineering in agriculture, and their societal implications by suggesting that these technologies are wholly effective or universally accepted solutions without considering other critical factors such as socioeconomic conditions, biodiversity concerns, human health implications, ethical considerations, and public resistance.

– False: The statement is false because it disregards the multifacited nature of hunger, which cannot be effectively addressed solely through advancements in agricultural technology without considering socioeconomic factors such as distribution and accessibility (False Assumption 1). It also neglects potential negative consequences on biodiversity or human health (False Assumption 2) and assumes that genetic engineering is universally accepted without acknowledging ethical concerns or public resistance (False Assumption 3).

– Debatable: The statement could be debated, as it presents a viewpoint supported by technological optimism. However, the information provided highlights various challenges, such as socioeconomic factors, biodiversity impacts, and ethical concerns that might lead to an

Assumptions

– Hunger persists despite advancements in agricultural technology, indicating that current methods may not be sufficient or accessible to all populations.

– The potential for genetic engineering to address nutritional deficiencies could have far-reaching impacts on global health and development.

– Considering the ethical implications is crucial as it affects future generations and biodiversity.

II. Background Information

A. Definition of genetic engineering in agriculture

B. Historical context of genetic modification (GM) crops

C. Current state of genetic engineering practices globally

III. Thesis Statement

– “While the ethical concerns surrounding genetic engineering in agriculture are significant, its use can be justified if it is conducted with careful consideration of long-term environmental and socioeconomic impacts.”

IV. Argument 1: Enhanced Crop Yield to Combat Global Hunger

A. Supporting Evidence

1. Statistical data on current crop yields vs. potential genetic engineering outcomes

2. Case studies of successful implementation in various

Fact Checker Output

– False Assumption 1: Hunger can be effectively addressed solely through advancements in agricultural technology without considering socioeconomic factors such as distribution and accessibility.

– Reasoning: While technological improvements are essential, they must be coupled with strategies to distribute food equitably and ensure that all populations have the means to benefit from these advances.

– False Assumption 2: Genetic engineering in agriculture has no potential negative consequences on biodiversity or human health.

– Reasoning: There are concerns regarding unintended ecological effects, gene transfer to non-target species, and the long-term health implications of consuming genetically modified organisms (GMOs). These factors must be taken into account when considering its use.

– False Assumption III: Genetic engineering in agriculture is universally accepted as a solution to food security without any ethical concerns or public resistance.

– Reasoning: Public perception and ethical considerations, such as the manipulation of nature and corporate control over seeds, vary widely across different cultures and communities, leading to debates on its

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="fact_checker_mongodb.py",
            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)