Status: True

Assertion

Sunflowers track the sun across the sky.

Results

Sunflowers exhibit tropisms, specifically heliotropism, which is their ability to track the sun’s movement across the sky. This motion primarily occurs in response to light (phototropism) and aids in maximizing photosynthetic efficiency by exposing more surface area of leaves to sunlight during different times of day.

4. True – The east-west motion pattern observed in young sunflower plants is indeed influenced by the directional light, which causes differential growth rates on opposite sides of the plant’s stem or flower head. This phenomenon aligns with phototropism as a primary factor driving their heliotropic behavior.

5. True – The east-west motion in young sunflowers serves to increase their exposure to light during different times of the day, which enhances photosynthesis and ensures maximum energy absorption for growth and development. This movement pattern maximizes the potential for capturing solar radiation effectively across varying periods.

Assumptions

To fully support the statement regarding sunflowers and their specific type of heliotropism, several assumptions can be made:

1. **Sunflowers exhibit tropisms**: The assumption that sunflowers show directed growth responses based on environmental stimuli is crucial for understanding their movement toward light (heliotropism).

2. **Light as a primary directional cue**: It’s assumed that the primary factor guiding the east-west motion in sunflowers is light, rather than other factors like gravity or touch. This assumption underpins the term “heliotropism,” which directly implies movement towards (or away from) the Sun.
Written by an expert with a PhD in Plant Physiology: Heliotropism in sunflowers involves two distinct movements – the diurnal motion and the more general response to light direction, known as phototropism. The specific east-west cycle is called “sun tracking” or “solar tracking,” which maximizes photosynthetic efficiency by ensuring maximum light absorption throughout different times of day.
2. **Photosynthesis efficiency**: There’s an assumption that the daily movement toward and away from sun

Fact Checker Output

<|assistant|> 1. True – Sunflowers do exhibit tropisms, which are directed growth responses to environmental stimuli. Heliotropism in sunflowers specifically refers to the directional movement of the plant’s stem and flower heads in response to light (phototropism), demonstrating that they indeed show a clear heliotropic behavior as part of their overall tropic responses.

2. True – The primary factor guiding the east-west motion in sunflowers is light, making it true that this movement can be primarily attributed to phototropism. While other environmental cues like gravity (gravitropism) and touch (thigmotropism) can influence plant growth, the unique heliotropic behavior of sunflowers involves tracking the Sun’s movement across the sky in response to light as their main stimulus.

3. True – The purpose of the daily east-west motion of sunflowers is indeed related to maximizing photosynthetic efficiency by ensuring maximum light absorption throughout different times of day, thus supporting efficient energy production through photosynthesis. This behavior increases the surface area exposed to sunlight during specific periods, enhancing their ability to capture as much solar

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)