Break down reasoning

<?php
require 'examples/boot.php';

use Cognesy\Instructor\StructuredOutput;
use Cognesy\Schema\Attributes\Description;

enum Prediction : string { case False = 'False'; case True = 'True'; case Unknown = 'Unknown'; }

class Proposition {
    public string $premise1 = '';
    public string $premise2 = '';
    public string $reasoning = '';
    public string $proposition = '';
}

class ProposerOutput {
    public string $reasoning = '';
    #[Description('List of deduced propositions, each with two source premises, reasoning, and the resulting proposition statement')]
    /** @var Proposition[] */
    public array $valid_propositions = [];
    public Prediction $prediction = Prediction::Unknown;
}

class VerifiedProposition {
    public string $proposition = '';
    public string $reasoning = '';
    public bool $is_valid = false;
}

class ReporterOutput {
    public string $reasoning = '';
    public bool $is_valid_hypothesis = false;
}

class CumulativeReasoningPipeline {
    public function propose(array $premises, string $hypothesis) : ProposerOutput {
        $formatted = '- ' . implode("\n- ", $premises);
        $sys = <<<SYS
            Think step by step using FOL to deduce propositions from given premises (at most two per deduction).
            Avoid duplicating premises; reason only from stated premises/propositions.
            SYS;
        $user = <<<USR
            Premises:
            {$formatted}

            We want to deduce more Propositions to determine correctness of the following Hypothesis:
            Hypothesis: {$hypothesis}
            USR;
        return StructuredOutput::using('openai')->with(
            model: 'gpt-4o-mini',
            responseModel: ProposerOutput::class,
            messages: [
                ['role' => 'system', 'content' => $sys],
                ['role' => 'user', 'content' => $user],
            ],
        )->get();
    }

    public function verify(ProposerOutput $proposal) : array {
        $results = [];
        foreach ($proposal->valid_propositions as $p) {
            $sys = 'Use FOL to determine whether the deduction from two premises to the proposition is valid.';
            $user = "Premises:\n{$p->premise1}\n{$p->premise2}\n\nProposition:\n{$p->proposition}";
            $res = StructuredOutput::using('openai')->with(
                model: 'gpt-4o-mini',
                responseModel: VerifiedProposition::class,
                messages: [ ['role' => 'system', 'content' => $sys], ['role' => 'user', 'content' => $user] ],
            )->get();
            $results[] = $res;
        }
        return $results;
    }

    public function report(array $verificationResult, string $hypothesis, array $premises) : ReporterOutput {
        $formattedPrem = '- ' . implode("\n- ", $premises);
        $props = [];
        foreach ($verificationResult as $v) { if ($v->is_valid) { $props[] = $v->proposition; } }
        $formattedProp = '- ' . implode("\n- ", $props);
        $sys = <<<SYS
            Think step by step. Read and analyze the Premises, then use FOL to judge whether the Hypothesis is True, False, or Unknown using the verified Propositions.
            SYS;
        $messages = [
            ['role' => 'system', 'content' => $sys],
            ['role' => 'user', 'content' => "Premises:\n{$formattedPrem}\n\nHypothesis: {$hypothesis}"],
            ['role' => 'assistant', 'content' => "Let's think step by step. From the premises, we can deduce the following propositions:\n{$formattedProp}\n\nRecall the Hypothesis: {$hypothesis}"],
        ];
        return StructuredOutput::using('openai')->with(
            model: 'gpt-4o-mini', responseModel: ReporterOutput::class, messages: $messages,
        )->get();
    }
}

$hypothesis = 'Hyraxes lay eggs';
$premises = [
    'The only types of mammals that lay eggs are platypuses and echidnas',
    'Platypuses are not hyrax',
    'Echidnas are not hyrax',
    'No mammals are invertebrates',
    'All animals are either vertebrates or invertebrates',
    'Mammals are animals',
    'Hyraxes are mammals',
    'Grebes lay eggs',
    'Grebes are not platypuses and also not echidnas',
];

$pipeline = new CumulativeReasoningPipeline();
$proposal = $pipeline->propose($premises, $hypothesis);
$verified = $pipeline->verify($proposal);
$report = $pipeline->report($verified, $hypothesis, $premises);

dump($proposal, $verified, $report);

assert($proposal instanceof ProposerOutput);
assert(!empty($proposal->reasoning));
assert(!empty($proposal->valid_propositions));
assert($proposal->prediction instanceof Prediction);
assert(is_array($verified));
assert(!empty($verified));
foreach ($verified as $v) {
    assert($v instanceof VerifiedProposition);
    assert(!empty($v->proposition));
}
assert($report instanceof ReporterOutput);
assert(!empty($report->reasoning));
?>