Status: True

Assertion

Homeschooling is better than public schooling.

Results

The statement contains elements that are generally accurate regarding homeschooling, although it’s important to note that individual experiences can vary. For example, while personalized learning is a benefit of homeschooling (1), the effectiveness relies on parental ability and commitment (2). Homeschool environments may offer fewer distractions (3) but also lack the structured socialization found in traditional schools (4). Access to resources can be variable depending on socioeconomic factors (5).

– Debatable: The statement touches upon aspects of homeschooling that are subjective and dependent on individual circumstances. For instance, the degree of personalized learning and effective social development will vary from one family to another based on various factors like parental skills, resources availability, and community involvement (1, 4).

– False: The statement presents an overly generalized perspective that may not hold true for all homeschooling experiences. While some aspects might be accurate, it ignores the diversity within the homeschooling community regarding learning styles, socialization methods, and access to resources (2, 3, 4, 5).

Assumptions

– Homeschooling allows for greater personalization in learning, as parents can tailor education to their child’s interests and pace.
– Parents or guardians have sufficient knowledge and skills to effectively educate and mentor their children at home.
– The homeschooling environment is conducive to effective learning without significant distractions that are present in public school settings.
– Social development can be achieved through alternative means outside of the traditional classroom, such as extracurricular activities, community involvement, and peer groups.
– Parents have access to resources (e.g., curriculum materials, learning aids, educational technology) necessary for homeschooling.
– There is an agreement among parents on the value of education and their commitment to invest time and effort into their child’s education at home.
– The statement implies that public schools may not fully cater to each student’s individual needs as effectively as a personalized homeschool environment can, which in itself is subjective and varies from case to case.

These assumptions provide the necessary groundwork for supporting the claim made in the original statement about the benefits of homeschooling over public schools. However

Fact Checker Output

<|assistant|> 1. True – Homeschooling does allow for greater personalization because parents can adapt the learning process to their child’s specific interests and learning pace. This tailored approach enables a more individualized education plan that may not be possible in public schools where resources are shared among many students.

2. False or Conditional – While some parents might have sufficient knowledge and skills, this assumption generalizes all homeschooling families. The effectiveness of parent-led education can vary widely depending on the parent’s background, expertise in certain subjects, and their commitment to continuous learning alongside their child.

3. True or Conditional – Homeschooled environments may be less distracted than traditional schools; however, this depends on various factors such as family dynamics, living conditions, and individual circumstances that can affect the level of concentration during homeschooling.

4. True – Social development is achievable through alternative means outside traditional classrooms. Homeschooled children often participate in extracurrran activities like sports teams, clubs, volunteer organizations, or social groups, which provide opportunities for interaction and growth.

5. True but Conditional – Access to resources can vary among

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)