modello

Start modelling

  • Start modelling
    • 1. Relate scalar quantities
    • 2. Compose models
      • Join components with a shared quantity
    • 3. Model collections and fit parameters
    • 4. Relate states across a sequence
    • Keep alternatives and check observations
    • Try the same questions interactively
  • Explore the fundamentals
    • The same five questions
    • Apply the ideas to your own problem

Modelling guides

  • Choose a modelling approach
    • Relate quantities or reuse a component
    • Differentiate or integrate a formula
    • Work with finite data and indexed formulas
    • Express relative evolution
      • Query a scalar law without choosing a horizon
      • Solve a finite window of model states
  • Component models
    • Reuse a smaller model
    • Infer a quantity inside a component
    • Connect quantities in different children
    • Use the same model for new observations
  • Vectors and indexed formulas
    • Start with observations
    • Operations
    • Comprehensions
    • Custom scalar operations
    • Inspection and solution families
    • Calculus uses SymPy
  • Scalar recurrence queries
    • One relative law, many queries
    • History and domains
    • Let observations choose the window
    • API
      • Series
      • Recurrence
  • Finite state sequences
    • Choose a sequence representation
    • An account across executions
    • Partial observations and inverse solving
    • Boundaries and formulas
    • Exploring the model
    • API
      • model_vector()
      • ModelVector
      • model_recurrence()
      • ModelRecurrence
      • ModelObservations
  • Explore a solution family
    • Continue with SymPy
    • Refine observations and select a state
    • Take a section through a reference
    • Continue after an exception
    • Guarantees and current scope
    • Reference
      • SolutionFamily
      • SolutionFamily.format()
      • SolutionFamily.latex()
      • SolutionFamily.expression()
      • SolutionFamily.values()
      • SolutionFamily.where()
      • SolutionFamily.observe()
      • SolutionFamily.section()
      • SolutionFamily.cases()
      • SolutionFamily.one()
      • SolutionIssue
      • SolutionSelectionError
      • UnresolvedSolutionError
  • Work with SymPy
    • Write native expressions
    • Choose symbols by their role
    • Exchange finite vector data
    • Reuse your own operations
    • Continue an analysis in SymPy
    • Return an answer for validation
    • Preserve the original mathematical question
  • Debugging a model
    • Inspect what remains symbolic
    • Distinguish redundancy from contradiction
    • Resolve ambiguity with a meaningful constraint
    • Inspect components and their connections
    • Ask for evidence explicitly
  • Interactive model explorer (WIP)
    • Quickstart: your own explorer
    • Choosing what you know
    • Vectors and indexed formulas
    • Understanding the interface
    • Starting from your model
    • Descriptions, units, and guided questions
    • Exact edits and validation
    • Scope of this draft
    • Typed model vectors
    • Mathematical rendering
    • API
      • BindingError
      • Explorer
      • FieldInfo
      • ModelInfo
      • Scenario
      • create_app()
      • gui()

Reference

  • API reference
    • Modello
      • Modello.__init__()
    • inspect_model()
    • component()
    • InstanceDummy
      • InstanceDummy.bound()
    • BoundInstanceDummy
    • SymbolicScalar
    • SymbolicCondition
    • SymbolicVector
    • Coordinates and indexed formulas
      • Coordinate
      • Index
      • Vector
      • vector()
    • Extension annotations
      • Annotation
      • annotate()
      • annotate_model()
    • Errors
      • ModelloError
      • ModelInputError
      • ModelValidationError
      • ModelDefinitionError
      • ModelSolveError
      • SolutionCountError
      • SolverBackendError
  • Generality and solver boundaries
    • Representations and composition
    • Validity and solver results
    • One-state Itô extension
    • Mathematical and computational scope
  • Diagnostic guarantees and reference
    • What each conclusion establishes
    • Checking a supplied assignment
    • Conflicts, probes, and costs
    • Research and SymPy foundations
    • Recorded problems and reports
      • ModelProblem
      • ModelField
      • ConstraintKind
      • ModelConstraint
      • ComponentView
      • Candidate
      • FieldValue
      • CandidateCheck
      • Verdict
      • SolutionSet
      • ResidualCheck
      • AssumptionCheck
      • ProblemAnalysis
      • LinearAnalysis
      • LinearCertificate
      • Conflict
      • RemovalCheck
      • InputCheck

Extensions

  • Stochastic processes
    • Declare your own process
    • Supported process queries
    • API
      • ItoProcess
  • Validate recorded rows
    • Find an accounting break
    • What a result contains
    • Audit coverage
    • Input and numerical values
    • Streams and manual windows
    • API
      • WindowValidator
      • ValidationResult
      • CheckResult
      • ValidationSummary
  • Deductive verification of model properties
    • Read an obligation in its context
    • Reference: contracts, domains, and proof limits
      • Select inputs and read model fields
      • Name an investigation’s proof declarations
      • Specifications, obligations, and inference rules
      • Model and component contracts
      • Retire explicit assumptions and obligations
      • Coordinates and observation domains
      • Property truth and proof attempts
      • Methods and inference rules
      • Write the record-review method’s contract
      • Help an open proof with a checked bound
    • API
      • Workflow objects
      • Mathematical conditions
      • Returned evidence and results

Recipes

  • Validate pandas and Polars DataFrames
    • Validate pandas rows
      • MultiIndex columns
    • Stream a Polars lazy query

Applications

  • Practical component models
    • Invoice reconciliation
    • Material requirements and yield
    • Circuit measurements
    • Choosing model boundaries
  • How much time should we spend checking a record?
    • Start with the workload budget
    • Model a short check
    • Build up a longer check
    • Reuse the derivation
    • Count the benefit and cost in minutes
    • State what the calculation needs
    • Find the parameter condition
    • Compose the decision model
    • Ask about quality and limits
    • Propose checking minutes
    • Explain why it is a global optimum
    • Change the repair-time estimate
    • Try a different response without changing the argument
    • Learn from a failed replacement
    • Separate a policy target from a mathematical premise
    • Keep evidence with the decision
    • Change an observation: checking can introduce errors
      • View the same outcomes as transitions
      • Check the transition properties in the same context
      • Derive a continuous response from shorter steps
  • An account across executions
    • Post executions and reconcile a balance
    • Join a valuation view
    • Explore further
  • Reconcile trade profit and loss
    • A small reconciliation framework
      • Try common mistakes first
      • Use inverse solving when needed
      • Read the evidence
      • Choose what may change
    • The model and its conventions
    • Read the formula
    • Find the break
    • Try common mistakes
    • Infer inputs and add evidence
    • Compare source components
  • Bound a prediction from an uncertain observation
    • Discover where a projectile can reach

Development

  • Contributing and releases
    • Validation
    • Review before a PR
    • Reading the core
    • Two sequence evaluation strategies
    • Read the Docs
    • Publishing
modello
  • Search


© Copyright 2018, Oliver Bristow.

Built with Sphinx using a theme provided by Read the Docs.