Status: True

Assertion

Pregnancy lasts 9 months.

Results

The general statements provided align with commonly understood concepts regarding pregnancy timelines. However, it’s crucial to acknowledge that individual experiences can vary. For example, the exact duration of each trimester may differ slightly between individuals, and while these stages are useful for a broad understanding, they don’t capture every nuance or anomaly in fetal development or maternal pregnancy experience. These statements serve as a general guideline but should not be taken as definitive predictions for all cases.

– True: The calculation of gestational age from the last menstrual period (LMP) is an established method, though it may have some margin of error due to natural variations in ovulation timing among women. Other methods like ultrasound measurements are sometimes more accurate but also depend on various factors such as maternal body habitus and fetal positioning at scanning time.

– True: The division of pregnancy into three trimesters offers a simplified, approximate breakdown that helps expectant parents understand the general timeline of developmental milestones throughout gestation. However, there is significant variability in individual experiences and these stages are not rigidly defined for every single case.

Assumptions

<|assistant|> – The standard measure for pregnancy duration is based on the woman’s last menstrual period (LMP), not actual conception date, due to varying ovulation and fertilization times among women.

– Pregnancy is typically divided into three trimesters of roughly equal length but with some variation in weeks across different sources.

– The development stages referred to in each trimester are approximate generalizations rather than precise timelines for every individual pregnancy.

– It’s understood that risk factors, such as miscarriage, can vary widely based on genetics, lifestyle, and environmental factors, and the statement doesn’t imply a uniform risk across all women.

– The comfort level described in the second trimester is subjective and may not apply to all expectant mothers; some might continue experiencing discomfort or morning sickness beyond this period.

– Feeling the baby move, as mentioned for week 20, can vary among pregnancies but typically occurs within a range of weeks rather than an exact date.

– The duration from week 29 to birth is not specified in terms of days or hours and may slightly differ depending on

Fact Checker Output

Solution: All the assertions listed are generally true based on common knowledge regarding pregnancy timelines. However, they also contain generalizations that don’t hold for every individual case. Here are explanations for why these assumptions are considered true within a broad context but with acknowledgment of their limitations in specific cases:

– True: The duration of pregnancy is often calculated from the last menstrual period (LMP) because it provides an estimated date when fertilization likely occurred, although conception can vary widely. This method has been used historically for its convenience and simplicity despite not being medically exact due to variations in ovulation timing among women.

– True: Pregnancy is conventionally divided into three trimesters of approximately equal duration (39 weeks total), with a slight variation that may cause one or two weeks’ difference between the third trimester’s start and end dates, as well as some variability in the length of each trimester.

– True: The developmental stages described for each trimester are approximate averages meant to provide a general framework for understanding fetal growth during pregnancy. Pregnancy progression can differ significantly among individual cases due to genetic, environmental

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)