Struct EpistemicProbProductionAdapter 

pub struct EpistemicProbProductionAdapter { /* private fields */ }

Thin adapter from accepted epistemic evidence to the existing GPU exact path.

Implementations

impl EpistemicProbProductionAdapter

pub fn new(config: GpuConfig) -> Self

Create a production adapter with a GPU exact inference configuration.

pub fn trace(&self) -> EpistemicProbProductionTrace

Return current production-path trace counters.

pub fn apply_accepted_world_view_to_circuit( &mut self, circuit: &mut EpistemicCircuit, evidence: AcceptedWorldViewEvidence, ) -> Result<CircuitUpdate>

Apply accepted world-view evidence to a caller-owned incremental circuit fixture.

This records the accepted evidence boundary and zero-CPU guard, but it is not a production metric event. Production metric eligibility still requires an existing GPU exact/provenance/PIR/CNF/knowledge-compilation path counter.

pub fn apply_accepted_world_view_to_circuit_with_gpu_execution_result( &mut self, circuit: &mut EpistemicCircuit, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<CircuitUpdate>

Apply accepted GPU epistemic execution evidence to a caller-owned incremental circuit.

pub fn apply_accepted_world_views_to_circuit_for_gpu_batch_execution_result( &mut self, circuit: &mut EpistemicCircuit, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<CircuitUpdate>>

Apply accepted split/batch GPU epistemic execution evidence to an incremental circuit.

pub fn compile_source_with_accepted_world_view( &mut self, source: &str, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactDdnnfProgram>

Compile source through the existing GPU-native exact/provenance path.

pub fn compile_source_with_gpu_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactDdnnfProgram>

Compile source through the GPU exact path after accepted GPU epistemic execution.

pub fn compile_source_for_gpu_execution_results( &mut self, source: &str, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactDdnnfProgram>>

Compile source once per accepted GPU epistemic execution result.

pub fn compile_source_for_gpu_batch_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactDdnnfProgram>>

Compile source once per accepted split/batch GPU epistemic component.

pub fn compile_program_with_accepted_world_view( &mut self, program: &Program, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactDdnnfProgram>

Compile a parsed program through the existing GPU-native exact/provenance path.

pub fn compile_program_with_gpu_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactDdnnfProgram>

Compile a parsed program through the GPU exact path after accepted GPU epistemic execution.

pub fn compile_program_for_gpu_execution_results( &mut self, program: &Program, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactDdnnfProgram>>

Compile a parsed program once per accepted GPU epistemic execution result.

pub fn compile_program_for_gpu_batch_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactDdnnfProgram>>

Compile a parsed program once per accepted split/batch GPU epistemic component.

pub fn compile_and_evaluate_source_with_accepted_world_view( &mut self, source: &str, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResult>

Compile source and evaluate queries through the existing GPU exact path after one accepted gate.

pub fn compile_and_evaluate_source_with_gpu_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResult>

Compile source and evaluate queries after accepted GPU epistemic execution.

pub fn compile_and_evaluate_source_for_gpu_execution_results( &mut self, source: &str, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResult>>

Compile and evaluate source once per accepted GPU epistemic execution result.

pub fn compile_and_evaluate_source_for_gpu_batch_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResult>>

Compile and evaluate source once per accepted split/batch GPU epistemic component.

pub fn compile_and_evaluate_conditioned_source_with_accepted_world_view( &mut self, source: &str, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResult>

Compile source with accepted zero-arity epistemic assumptions as exact evidence.

pub fn compile_and_evaluate_conditioned_source_with_gpu_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResult>

Compile source with accepted GPU epistemic assumptions as exact evidence.

pub fn compile_and_evaluate_conditioned_source_for_gpu_execution_results( &mut self, source: &str, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResult>>

Compile conditioned source once per accepted GPU epistemic execution result.

pub fn compile_and_evaluate_conditioned_source_for_gpu_batch_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResult>>

Compile conditioned source once per accepted split/batch GPU epistemic component.

pub fn compile_and_evaluate_conditioned_source_with_grads_with_accepted_world_view( &mut self, source: &str, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResultWithGrads>

Compile source with accepted epistemic assumptions as exact evidence and evaluate gradients.

pub fn compile_and_evaluate_conditioned_source_with_grads_with_gpu_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResultWithGrads>

Compile source with accepted GPU epistemic assumptions as exact evidence and evaluate gradients.

pub fn compile_and_evaluate_conditioned_source_with_grads_for_gpu_execution_results( &mut self, source: &str, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResultWithGrads>>

Compile conditioned source gradients once per accepted GPU epistemic execution result.

pub fn compile_and_evaluate_conditioned_source_with_grads_for_gpu_batch_execution_result( &mut self, source: &str, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResultWithGrads>>

Compile conditioned source gradients once per accepted split/batch GPU epistemic component.

pub fn compile_and_evaluate_conditioned_program_with_accepted_world_view( &mut self, program: &Program, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResult>

Compile a parsed program with accepted epistemic assumptions as exact evidence.

pub fn compile_and_evaluate_conditioned_program_with_gpu_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResult>

Compile a parsed program with accepted GPU epistemic assumptions as exact evidence.

pub fn compile_and_evaluate_conditioned_program_for_gpu_execution_results( &mut self, program: &Program, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResult>>

Compile conditioned parsed program once per accepted GPU epistemic execution result.

pub fn compile_and_evaluate_conditioned_program_for_gpu_batch_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResult>>

Compile conditioned parsed program once per accepted split/batch GPU epistemic component.

pub fn compile_and_evaluate_conditioned_program_with_grads_with_accepted_world_view( &mut self, program: &Program, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResultWithGrads>

Compile a parsed program with accepted epistemic assumptions as exact evidence and evaluate gradients.

pub fn compile_and_evaluate_conditioned_program_with_grads_with_gpu_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResultWithGrads>

Compile a parsed program with accepted GPU epistemic assumptions as exact evidence and evaluate gradients.

pub fn compile_and_evaluate_conditioned_program_with_grads_for_gpu_execution_results( &mut self, program: &Program, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResultWithGrads>>

Compile conditioned parsed-program gradients once per accepted GPU epistemic execution result.

pub fn compile_and_evaluate_conditioned_program_with_grads_for_gpu_batch_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResultWithGrads>>

Compile conditioned parsed-program gradients once per accepted split/batch GPU epistemic component.

pub fn compile_and_evaluate_program_with_accepted_world_view( &mut self, program: &Program, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResult>

Compile a parsed program and evaluate queries through the existing GPU exact path.

pub fn compile_and_evaluate_program_with_gpu_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResult>

Compile a parsed program and evaluate queries after accepted GPU epistemic execution.

pub fn compile_and_evaluate_program_for_gpu_execution_results( &mut self, program: &Program, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResult>>

Compile and evaluate a parsed program once per accepted GPU epistemic execution result.

pub fn compile_and_evaluate_program_for_gpu_batch_execution_result( &mut self, program: &Program, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResult>>

Compile and evaluate a parsed program once per accepted split/batch GPU epistemic component.

pub fn encode_source_pir_cnf_with_accepted_world_view( &mut self, source: &str, provider: &Arc<CudaKernelProvider>, evidence: &AcceptedWorldViewEvidence, ) -> Result<EpistemicProbPirCnfEvidence>

Encode source through the existing GPU PIR and CNF production path.

pub fn encode_source_pir_cnf_with_gpu_execution_result( &mut self, source: &str, provider: &Arc<CudaKernelProvider>, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<EpistemicProbPirCnfEvidence>

Encode source PIR/CNF after accepted GPU epistemic execution.

pub fn encode_source_pir_cnf_for_gpu_execution_results( &mut self, source: &str, provider: &Arc<CudaKernelProvider>, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<EpistemicProbPirCnfEvidence>>

Encode source PIR/CNF once per accepted GPU epistemic execution result.

pub fn encode_source_pir_cnf_for_gpu_batch_execution_result( &mut self, source: &str, provider: &Arc<CudaKernelProvider>, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<EpistemicProbPirCnfEvidence>>

Encode source PIR/CNF once per accepted split/batch GPU epistemic component.

pub fn encode_program_pir_cnf_with_accepted_world_view( &mut self, program: &Program, provider: &Arc<CudaKernelProvider>, evidence: &AcceptedWorldViewEvidence, ) -> Result<EpistemicProbPirCnfEvidence>

Encode a parsed program through the existing GPU PIR and CNF production path.

pub fn encode_program_pir_cnf_with_gpu_execution_result( &mut self, program: &Program, provider: &Arc<CudaKernelProvider>, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<EpistemicProbPirCnfEvidence>

Encode parsed-program PIR/CNF after accepted GPU epistemic execution.

pub fn encode_program_pir_cnf_for_gpu_execution_results( &mut self, program: &Program, provider: &Arc<CudaKernelProvider>, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<EpistemicProbPirCnfEvidence>>

Encode parsed-program PIR/CNF once per accepted GPU epistemic execution result.

pub fn encode_program_pir_cnf_for_gpu_batch_execution_result( &mut self, program: &Program, provider: &Arc<CudaKernelProvider>, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<EpistemicProbPirCnfEvidence>>

Encode parsed-program PIR/CNF once per accepted split/batch GPU epistemic component.

pub fn evaluate( &mut self, program: &ExactDdnnfProgram, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResult>

Evaluate GPU exact query probabilities after accepted world-view evidence was consumed.

pub fn evaluate_with_gpu_execution_result( &mut self, program: &ExactDdnnfProgram, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResult>

Evaluate GPU exact query probabilities after accepted GPU epistemic execution.

pub fn evaluate_for_gpu_execution_results( &mut self, program: &ExactDdnnfProgram, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResult>>

Evaluate GPU exact query probabilities once per accepted GPU epistemic execution result.

pub fn evaluate_for_gpu_batch_execution_result( &mut self, program: &ExactDdnnfProgram, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResult>>

Evaluate GPU exact query probabilities once per accepted split/batch GPU epistemic component.

pub fn evaluate_gpu_with_grads( &mut self, program: &ExactDdnnfProgram, evidence: &AcceptedWorldViewEvidence, ) -> Result<ExactResultWithGrads>

Evaluate GPU exact gradients after accepted world-view evidence was consumed.

pub fn evaluate_gpu_with_grads_with_gpu_execution_result( &mut self, program: &ExactDdnnfProgram, provider: &CudaKernelProvider, result: &EpistemicGpuExecutionResult, assumptions: Vec<EpistemicAssumption>, ) -> Result<ExactResultWithGrads>

Evaluate GPU exact gradients after accepted GPU epistemic execution.

pub fn evaluate_gpu_with_grads_for_gpu_execution_results( &mut self, program: &ExactDdnnfProgram, provider: &CudaKernelProvider, evidence_records: &[EpistemicProbGpuExecutionEvidence<'_>], ) -> Result<Vec<ExactResultWithGrads>>

Evaluate GPU exact gradients once per accepted GPU epistemic execution result.

pub fn evaluate_gpu_with_grads_for_gpu_batch_execution_result( &mut self, program: &ExactDdnnfProgram, provider: &CudaKernelProvider, evidence: EpistemicProbGpuBatchExecutionEvidence<'_>, ) -> Result<Vec<ExactResultWithGrads>>

Evaluate GPU exact gradients once per accepted split/batch GPU epistemic component.