| ! | Database.Data |
| .&&. | Domain.Logic.Views |
| .->. | Domain.Logic.Views |
| .<->. | Domain.Logic.Views |
| .== | Bayes.Evidence |
| .=~ | Bayes.Evidence |
| .||. | Domain.Logic.Views |
| // | Util.String |
| <! | Recognize.Data.Attribute |
| <!> | Recognize.SubExpr.Symbols |
| <&> | Recognize.SubExpr.Symbols |
| <<?> | Recognize.Model.Connectives |
| <=> | Domain.Logic.Utils |
| <?> | Recognize.SubExpr.Symbols |
| <?>> | Recognize.Model.Connectives |
| <||> | Recognize.Model.Connectives |
| <~> | Recognize.Model.Connectives |
| =/= | Domain.Math.Power.Utils |
| === | |
| 1 (Function) | Domain.Logic.Utils |
| 2 (Function) | Domain.Math.Power.Utils |
| 3 (Function) | Recognize.Expr.Normalform |
| ==> | |
| 1 (Function) | Domain.Logic.Utils |
| 2 (Function) | Recognize.Model.Connectives |
| >*< | Recognize.Parsing.Interpretation |
| >+< | Recognize.Parsing.Interpretation |
| >-< | Recognize.Parsing.Interpretation |
| >/< | Recognize.Parsing.Interpretation |
| >>*<< | Recognize.Parsing.Interpretation |
| >>+<< | Recognize.Parsing.Interpretation |
| >>/<< | Recognize.Parsing.Interpretation |
| >^< | Recognize.Parsing.Interpretation |
| abcBuggyRules | Domain.Math.Polynomial.BuggyRules |
| abcFormula | Domain.Math.Polynomial.Rules |
| acExpr | Domain.Math.CleanUp |
| Add | Recognize.Data.Op |
| add | Domain.LinearAlgebra.Matrix |
| add2C | Task.MagicTrick.Assess |
| add8C | Task.MagicTrick.Assess |
| addAttribute | Recognize.Data.Step, Recognize.Data.Diagnosis |
| addAttributes | Recognize.Data.Step |
| addCell | Util.TableData |
| addCol | Util.TableData |
| addExponents | Domain.Math.Power.Rules |
| addMatching | Recognize.SubExpr.SEParser |
| addModelToLatestRequest | Bayes.Script |
| addNode | Bayes.Network |
| addRow | |
| 1 (Function) | Domain.LinearAlgebra.Matrix |
| 2 (Function) | Util.TableData |
| addVirtualNodes | Bayes.Evidence |
| addWildcardConstraint | Recognize.Parsing.Interpretation |
| addXC | Task.MagicTrick.Assess |
| adjust | Database.Data |
| adviseMeDr | Service.AdviseMe |
| aggregateConcepts | Bayes.Script |
| aggregateConcepts' | Bayes.Script |
| alg | Domain.Math.Numeric.Rules |
| Algebraic | Recognize.Data.Approach |
| allEvidence | Database.Data |
| allEvidenceStudents | Database.Data |
| allHumanAssessments | Database.Data |
| allM | Util.Monad |
| allowedWords | Recognize.Parsing.MathLexer |
| allPartialModels | Database.Data |
| allPowerFactors | Domain.Math.Polynomial.Rules |
| allProbabilities | Bayes.Evidence |
| allRecords | Database.Data |
| allStudentModels | Database.Data |
| alternativesExpr | Recognize.SubExpr.Functions |
| Analyzer | Recognize.Data.MathStoryProblem |
| analyzer | Recognize.Data.MathStoryProblem |
| analyzers | Recognize.Data.MathStoryProblem |
| ancestors | Bayes.Network |
| andRules | Domain.Logic.Strategies |
| andSymbol | Recognize.SubExpr.Symbols |
| andView | |
| 1 (Function) | Domain.Logic.Utils |
| 2 (Function) | Domain.Logic.Views |
| ans1 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.RectangleArea |
| 3 (Function) | Task.Network.Pattern |
| 4 (Function) | Task.Network.Matryoshka |
| 5 (Function) | Task.Network.MakingASquare |
| 6 (Function) | Task.Network.MagicTrick |
| 7 (Function) | Task.Network.CarRental |
| 8 (Function) | Task.Network.AreaOfATriangle |
| 9 (Function) | Task.Network.AreaAndExpression |
| ans1Strat | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MakingASquare |
| 5 (Function) | Task.Network.MagicTrick |
| 6 (Function) | Task.Network.CarRental |
| 7 (Function) | Task.Network.AreaAndExpression |
| ans1Strat1Step1 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.RectangleArea |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MakingASquare |
| 5 (Function) | Task.Network.MagicTrick |
| 6 (Function) | Task.Network.CarRental |
| 7 (Function) | Task.Network.AreaOfATriangle |
| ans1Strat1Step11 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.AreaAndExpression |
| ans1Strat1Step12 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.AreaAndExpression |
| ans1Strat1Step1Path | Task.Network.Pattern |
| ans1Strat1Step2 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MakingASquare |
| 5 (Function) | Task.Network.MagicTrick |
| 6 (Function) | Task.Network.CarRental |
| 7 (Function) | Task.Network.AreaOfATriangle |
| ans1Strat1Step3 | |
| 1 (Function) | Task.Network.Matryoshka |
| 2 (Function) | Task.Network.MakingASquare |
| 3 (Function) | Task.Network.MagicTrick |
| ans1Strat1Step31 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step32 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step3Path | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step4 | |
| 1 (Function) | Task.Network.Matryoshka |
| 2 (Function) | Task.Network.MakingASquare |
| 3 (Function) | Task.Network.MagicTrick |
| ans1Strat1Step41 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step42 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step5 | |
| 1 (Function) | Task.Network.Matryoshka |
| 2 (Function) | Task.Network.MakingASquare |
| 3 (Function) | Task.Network.MagicTrick |
| ans1Strat1Step51 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step52 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.CarRental |
| ans1Strat1Step6 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.MakingASquare |
| 3 (Function) | Task.Network.MagicTrick |
| 4 (Function) | Task.Network.CarRental |
| ans1Strat2Step1 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MakingASquare |
| 5 (Function) | Task.Network.MagicTrick |
| 6 (Function) | Task.Network.CarRental |
| ans1Strat2Step2 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MakingASquare |
| 5 (Function) | Task.Network.MagicTrick |
| 6 (Function) | Task.Network.CarRental |
| ans1Strat2Step3 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.Matryoshka |
| 3 (Function) | Task.Network.MakingASquare |
| 4 (Function) | Task.Network.MagicTrick |
| 5 (Function) | Task.Network.CarRental |
| ans1Strat2Step4 | |
| 1 (Function) | Task.Network.Matryoshka |
| 2 (Function) | Task.Network.MagicTrick |
| ans1Strat2Step5 | |
| 1 (Function) | Task.Network.Matryoshka |
| 2 (Function) | Task.Network.MagicTrick |
| ans1Strat2Step6 | |
| 1 (Function) | Task.Network.Matryoshka |
| 2 (Function) | Task.Network.MagicTrick |
| ans1Strat2Step7 | Task.Network.MagicTrick |
| ans1Strat3Step1 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MagicTrick |
| ans1Strat3Step10 | Task.Network.Matryoshka |
| ans1Strat3Step11 | Task.Network.Matryoshka |
| ans1Strat3Step2 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| 4 (Function) | Task.Network.MagicTrick |
| ans1Strat3Step3 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| ans1Strat3Step4 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.Pattern |
| 3 (Function) | Task.Network.Matryoshka |
| ans1Strat3Step5 | |
| 1 (Function) | Task.Network.Pattern |
| 2 (Function) | Task.Network.Matryoshka |
| ans1Strat3Step6 | Task.Network.Matryoshka |
| ans1Strat3Step7 | Task.Network.Matryoshka |
| ans1Strat3Step8 | Task.Network.Matryoshka |
| ans1Strat3Step9 | Task.Network.Matryoshka |
| ans1Strat4Step1 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.MagicTrick |
| ans1Strat4Step2 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.MagicTrick |
| ans1Strat4Step3 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.MagicTrick |
| ans1Strat4Step4 | Task.Network.MagicTrick |
| ans1Strat4Step5 | Task.Network.MagicTrick |
| ans1Strat4Step6 | Task.Network.MagicTrick |
| ans1Strat4Step7 | Task.Network.MagicTrick |
| ans2 | |
| 1 (Function) | Task.Network.TheatreRate |
| 2 (Function) | Task.Network.RectangleArea |
| 3 (Function) | Task.Network.AreaOfATriangle |
| ans2Strat | Task.Network.TheatreRate |
| ans2Strat1Step1 | |
| 1 (Function) | Task.Network.TheatreRate |
| 2 (Function) | Task.Network.AreaOfATriangle |
| ans2Strat1Step11 | Task.Network.RectangleArea |
| ans2Strat1Step12 | Task.Network.RectangleArea |
| ans2Strat1Step13 | Task.Network.RectangleArea |
| ans2Strat1Step14 | Task.Network.RectangleArea |
| ans2Strat1Step2 | |
| 1 (Function) | Task.Network.RectangleArea |
| 2 (Function) | Task.Network.AreaOfATriangle |
| ans2Strat1Step21 | Task.Network.TheatreRate |
| ans2Strat1Step22 | Task.Network.TheatreRate |
| ans2Strat1Step3 | Task.Network.TheatreRate |
| ans2Strat1Step41 | Task.Network.TheatreRate |
| ans2Strat1Step42 | Task.Network.TheatreRate |
| ans2Strat1Step4Path | Task.Network.TheatreRate |
| ans2Strat1Step51 | Task.Network.TheatreRate |
| ans2Strat1Step52 | Task.Network.TheatreRate |
| ans2Strat1Step61 | Task.Network.TheatreRate |
| ans2Strat1Step62 | Task.Network.TheatreRate |
| ans2Strat1Step7 | Task.Network.TheatreRate |
| ans2Strat2Step1 | Task.Network.TheatreRate |
| ans2Strat2Step2 | Task.Network.TheatreRate |
| ans2Strat2Step3 | Task.Network.TheatreRate |
| ans3 | |
| 1 (Function) | Task.Network.RectangleArea |
| 2 (Function) | Task.Network.AreaOfATriangle |
| ans3Strat | Task.Network.AreaOfATriangle |
| ans3Strat1Step1 | |
| 1 (Function) | Task.Network.RectangleArea |
| 2 (Function) | Task.Network.AreaOfATriangle |
| ans3Strat1Step2 | Task.Network.AreaOfATriangle |
| ans3Strat1Step3 | Task.Network.AreaOfATriangle |
| ans3Strat2Step1 | Task.Network.AreaOfATriangle |
| ans3Strat2Step2 | Task.Network.AreaOfATriangle |
| ans3Strat2Step3 | Task.Network.AreaOfATriangle |
| answerCorrect | Recognize.Model.Assess |
| anyM | Util.Monad |
| appLast | Util.List |
| applyFirstM | Util.Monad |
| applyMap | Recognize.Preprocessing |
| Approach | Recognize.Data.Approach |
| approach | Recognize.Data.Approach |
| approx | Recognize.Expr.Symbols |
| Approximation | |
| 1 (Type/Class) | Domain.Math.Approximation |
| 2 (Data Constructor) | Recognize.Data.Attribute |
| approxRelView | Recognize.Strategy.Views |
| approxSymbol | Recognize.Expr.Symbols |
| arbitraryPrintable | Recognize.Data.Math |
| Area | Recognize.Data.Attribute |
| areaAndExpression | Task.AreaAndExpression |
| areaOfATriangle | Task.AreaOfATriangle |
| Arithmetic | Recognize.Data.Approach |
| ARule | Recognize.Data.Attribute |
| ARuleR | Recognize.Data.Attribute |
| asciiTable | Main.Diagnose |
| assess' | |
| 1 (Function) | Task.VPattern.Assess |
| 2 (Function) | Task.TheatreRate.Assess |
| 3 (Function) | Task.Pattern.Assess |
| 4 (Function) | Task.Matryoshka.Assess |
| 5 (Function) | Task.MagicTrick.Assess |
| assocExpr | Domain.Math.CleanUp |
| associateToRight | Domain.Logic.Parser |
| assocPlus | Domain.Math.CleanUp |
| assocTimes | Domain.Math.CleanUp |
| asString | Recognize.Data.Math |
| AsymmetricRelation | Recognize.Data.Attribute |
| AtomMixedUp | Recognize.Data.Attribute |
| Attribute | Recognize.Data.Attribute |
| backward | Domain.LinearAlgebra.Matrix |
| balanced | Util.Parentheses |
| balanceExercise | Domain.Math.Polynomial.Balance |
| balanceOrder | Domain.Math.Polynomial.Balance |
| balanceStrategy | Domain.Math.Polynomial.Balance |
| bigStep | Recognize.Data.Step |
| binomialPolyView | Domain.Math.Polynomial.Views |
| bisection | Domain.Math.Approximation |
| breaksOn | Util.String |
| bringAToOne | Domain.Math.Polynomial.Rules |
| buggyBalanceExprRule | Domain.Math.Polynomial.BalanceUtils |
| buggyBalanceExprRules | Domain.Math.Polynomial.BuggyBalance |
| buggyBalanceRecognizer | Domain.Math.Polynomial.BalanceUtils |
| buggyBalanceRule | Domain.Math.Polynomial.BalanceUtils |
| buggyBalanceRuleArg | Domain.Math.Polynomial.BalanceUtils |
| buggyBalanceRules | Domain.Math.Polynomial.BuggyBalance |
| buggyPriority | Domain.Math.Polynomial.BuggyBalance |
| buggyQuadratic | Domain.Math.Polynomial.BuggyRules |
| buggyRules | Domain.Logic.BuggyRules |
| buggyRulesEquation | Domain.Math.Polynomial.BuggyRules |
| buggyRulesExpr | Domain.Math.Polynomial.BuggyRules |
| buggySquareMultiplication | Domain.Math.Polynomial.BuggyRules |
| buggySymbol | Recognize.SubExpr.Symbols |
| buildEvidence | Recognize.Model.EvidenceBuilder |
| buildStepsEvidence | |
| 1 (Function) | Task.VPattern.Assess |
| 2 (Function) | Task.TheatreRate.Assess |
| 3 (Function) | Task.Pattern.Assess |
| 4 (Function) | Task.Matryoshka.Assess |
| 5 (Function) | Task.MagicTrick.Assess |
| buildStudentReport | Bayes.StudentReport |
| cached | Util.Cache |
| cached2 | Util.Cache |
| cached3 | Util.Cache |
| cached4 | Util.Cache |
| calcBinRule | Domain.Math.Numeric.Rules |
| calcDivisionWith | Domain.Math.Numeric.Rules |
| calcMinusWith | Domain.Math.Numeric.Rules |
| calcPlainRoot | Domain.Math.Power.Rules |
| calcPlusWith | Domain.Math.Numeric.Rules |
| calcPower | Domain.Math.Power.Rules |
| calcPowerMinus | Domain.Math.Power.Rules |
| calcPowerPlus | Domain.Math.Power.Rules |
| calcPowerRatio | Domain.Math.Power.Rules |
| calcRuleName | Domain.Math.Numeric.Rules |
| calcTimesWith | Domain.Math.Numeric.Rules |
| calculate | Domain.Math.Polynomial.Balance |
| calculatePriors | Database.Priors |
| cancelTerms | Domain.Math.Polynomial.Rules |
| cancelTermsDiv | Domain.Math.Polynomial.RationalRules |
| CapturedWildcard | Recognize.Data.Attribute |
| carRental | Task.CarRental |
| cartProd | Util.List |
| category | Recognize.Data.Diagnosis |
| categoryAsString | Recognize.Data.Entry |
| categoryStatistics | Main.Diagnose |
| ceilingExpr | Recognize.Expr.Normalform |
| Cell | Main.ParserCSV |
| chainedEqSymbol | Recognize.Data.Math |
| chainedEquations | Recognize.SubExpr.SEParser |
| changeEntries | Domain.LinearAlgebra.Matrix |
| changeEntry | Domain.LinearAlgebra.Matrix |
| changeOp | Recognize.Expr.Functions |
| changeSet | Recognize.Expr.Functions |
| checkForChange | Domain.Math.Polynomial.BalanceUtils |
| checkSolution | Domain.Math.Polynomial.RationalRules |
| choice | Recognize.Parsing.Derived |
| choice' | Recognize.Parsing.Derived |
| choiceFor | Recognize.Parsing.Derived |
| choiceFor' | Recognize.Parsing.Derived |
| cleaner | Domain.Math.Polynomial.BalanceUtils |
| cleanerExpr | Domain.Math.Polynomial.BalanceUtils |
| cleanExpr | Recognize.SubExpr.Functions |
| cleanUpACView | Domain.Math.CleanUp |
| cleanUpExpr | Domain.Math.CleanUp |
| cleanUpRelation | Domain.Math.CleanUp |
| cleanUpRelations | Domain.Math.CleanUp |
| cleanUpSimple | Domain.Math.CleanUp |
| cleanUpView | Domain.Math.CleanUp |
| clear | Bayes.Evidence |
| clearWildcard | Recognize.Parsing.Interpretation |
| closestInList | Recognize.Expr.Functions |
| cnfStrategy | Domain.Logic.Strategies |
| colHeaders | Util.TableData |
| collect | |
| 1 (Function) | Domain.Logic.Utils |
| 2 (Function) | Domain.Math.Polynomial.Balance |
| collectGlobal | Domain.Math.Polynomial.BalanceUtils |
| collectIDs | Database.Data |
| collectInputs | Database.Data |
| collectLikeTerms | Domain.Math.Simplification |
| collectLocal | Domain.Math.Polynomial.BalanceUtils |
| collector | Recognize.Data.MathStoryProblem |
| collectSolution | Database.Data |
| collectSource | Database.Data |
| Collect_Num | Recognize.Data.RuleId |
| Collect_Var | Recognize.Data.RuleId |
| Color | Bayes.SVG |
| Column | |
| 1 (Type/Class) | Domain.LinearAlgebra.Matrix |
| 2 (Data Constructor) | Recognize.Data.StringLexer |
| column | Domain.LinearAlgebra.Matrix |
| columns | |
| 1 (Function) | Domain.LinearAlgebra.Matrix |
| 2 (Function) | Database.Data |
| combinePredicates | Recognize.Model.Constraint |
| commit | Database.Data |
| commonFactorVar | Domain.Math.Polynomial.Rules |
| commonFactorVarNew | Domain.Math.Polynomial.Rules |
| CommonMistake | Recognize.Data.Attribute |
| commOp | Domain.Math.Equation.CoverUpRules |
| Competence | |
| 1 (Type/Class) | Bayes.StudentReport |
| 2 (Data Constructor) | Bayes.StudentReport |
| competences | Bayes.StudentReport |
| con | Domain.Math.Data.MultivariatePolynomial |
| concatMapM | Util.List |
| Concept | Recognize.Data.Attribute |
| condition | Bayes.Factor |
| conditions | Bayes.Factor |
| conditionVarsRHS | Domain.Math.Polynomial.Rules |
| ConfigCoverUp | Domain.Math.Equation.CoverUpRules |
| configCoverUp | Domain.Math.Equation.CoverUpRules |
| configName | Domain.Math.Equation.CoverUpRules |
| conformsTo | Recognize.SubExpr.SEParser |
| conLeftMinus | Domain.Math.Polynomial.Balance |
| conLeftPlus | Domain.Math.Polynomial.Balance |
| conRight | Domain.Math.Polynomial.Balance |
| conRightMinus | Domain.Math.Polynomial.Balance |
| conRightPlus | Domain.Math.Polynomial.Balance |
| consPowerView | Domain.Math.Power.Views |
| constantFolding | Domain.Math.Simplification |
| constantPolyView | Domain.Math.Polynomial.Views |
| Constraint | |
| 1 (Type/Class) | Recognize.Model.Constraint |
| 2 (Data Constructor) | Recognize.Model.Constraint |
| convertToLowercase | Recognize.Data.MathParserOptions |
| correctResult | Recognize.Data.Diagnosis |
| Count | Util.Table |
| count | |
| 1 (Function) | Util.Table |
| 2 (Function) | Main.Diagnose |
| countEntries | Database.Data |
| countEntry | Main.Report |
| countResult | Main.Report |
| countStudentEntries | Database.Data |
| countStudents | Database.Data |
| countTaskEntries | Database.Data |
| coverLHS | Domain.Math.Equation.CoverUpRules |
| coverRHS | Domain.Math.Equation.CoverUpRules |
| coverUp | Domain.Math.Equation.CoverUpRules |
| coverUpBinaryRule | Domain.Math.Equation.CoverUpRules |
| coverUpDenominator | Domain.Math.Equation.CoverUpRules |
| coverUpDenominatorWith | Domain.Math.Equation.CoverUpRules |
| coverUpMinusLeft | Domain.Math.Equation.CoverUpRules |
| coverUpMinusLeftWith | Domain.Math.Equation.CoverUpRules |
| coverUpMinusRight | Domain.Math.Equation.CoverUpRules |
| coverUpMinusRightWith | Domain.Math.Equation.CoverUpRules |
| coverUpNegate | Domain.Math.Equation.CoverUpRules |
| coverUpNegateWith | Domain.Math.Equation.CoverUpRules |
| coverUpNumerator | Domain.Math.Equation.CoverUpRules |
| coverUpNumeratorWith | Domain.Math.Equation.CoverUpRules |
| coverUpOrs | Domain.Math.Equation.CoverUpRules |
| coverUpPlus | |
| 1 (Function) | Domain.Math.Equation.CoverUpRules |
| 2 (Function) | Recognize.Strategy.Strategies |
| coverUpPlusWith | Domain.Math.Equation.CoverUpRules |
| coverUpPower | Domain.Math.Equation.CoverUpRules |
| coverUpPowerWith | Domain.Math.Equation.CoverUpRules |
| coverUpRules | Domain.Math.Equation.CoverUpRules |
| coverUpRulesOr | Domain.Math.Equation.CoverUpRules |
| coverUpRulesX | Domain.Math.Power.Utils |
| coverUpSqrt | Domain.Math.Equation.CoverUpRules |
| coverUpSqrtWith | Domain.Math.Equation.CoverUpRules |
| coverUpTimes | Domain.Math.Equation.CoverUpRules |
| coverUpTimesPositive | Recognize.Strategy.Strategies |
| coverUpTimesWith | Domain.Math.Equation.CoverUpRules |
| Coverup_OneVar_Plus | Recognize.Data.RuleId |
| Coverup_Times_Positive | Recognize.Data.RuleId |
| CPT | Bayes.Network |
| createTable | Database.Data |
| crossMultiply | Domain.Math.Polynomial.RationalRules |
| CSV | Main.ParserCSV |
| csvTable | Util.TableData |
| cubicGen | Domain.Math.Polynomial.Generators |
| cubicPolyView | Domain.Math.Polynomial.Views |
| DE | Recognize.Data.Solution |
| defaultEntry | Database.Data |
| defaultModulo | Recognize.Parsing.Interpretation |
| defaultRecognizer | Recognize.Recognizer |
| defaultSolution | Recognize.Data.Solution |
| Definition | |
| 1 (Type/Class) | Recognize.Data.Definition |
| 2 (Type/Class) | Bayes.Network |
| 3 (Data Constructor) | Recognize.SubExpr.SEParser |
| definition | Bayes.Network |
| definitionView | Recognize.Data.Definition |
| defPowerNat | Domain.Math.Polynomial.Rules |
| deleteByM | Util.Monad |
| deMorgan | Domain.Logic.Strategies |
| deMorganAnd | Domain.Logic.Strategies |
| deMorganOr | Domain.Logic.Strategies |
| derivative | Domain.Math.Approximation |
| descendants | Bayes.Network |
| determineInputType | Recognize.SubExpr.SEParser |
| diagnose | Recognize.Data.MathStoryProblem |
| DiagnoseError | Recognize.Data.DiagnoseError |
| diagnoseMultiple | Main.Diagnose |
| DiagnoseResult | |
| 1 (Type/Class) | Recognize.Data.DiagnoseResult |
| 2 (Data Constructor) | Recognize.Data.DiagnoseResult |
| diagnoses | Recognize.Data.Entry |
| diagnoseSingle | Main.Diagnose |
| Diagnosis | |
| 1 (Type/Class) | Recognize.Data.Diagnosis |
| 2 (Data Constructor) | Recognize.Data.Diagnosis |
| diagnosis | Recognize.Data.DiagnoseResult |
| DiagnosisReply | |
| 1 (Type/Class) | Service.Types |
| 2 (Data Constructor) | Service.Types |
| diffPlus | Domain.Math.Polynomial.BalanceUtils |
| diffTimes | Domain.Math.Polynomial.BalanceUtils |
| Dimensional | Bayes.Factor |
| Dimensions | Bayes.Factor |
| dimensions | |
| 1 (Function) | Bayes.Factor |
| 2 (Function) | Domain.LinearAlgebra.Matrix |
| distrAnd | Domain.Logic.Strategies |
| distribute | Domain.Math.Polynomial.Balance |
| distributeDiv | Domain.Math.Polynomial.BalanceUtils |
| distributeDivision | Recognize.Strategy.Rules |
| distributeDivisionMulti | Domain.Math.Polynomial.Rules |
| distributeDivisionT | Domain.Math.Polynomial.Rules |
| distributeExponent | Recognize.Expr.Normalform |
| distributePower | Domain.Math.Power.Rules |
| distributePowerDiv | Domain.Math.Power.Rules |
| distributeTimes | |
| 1 (Function) | Domain.Math.Polynomial.BalanceUtils |
| 2 (Function) | Domain.Math.Polynomial.Rules |
| distribution | Domain.Math.Simplification |
| distributionSquare | Domain.Math.Polynomial.Rules |
| distrOr | Domain.Logic.Strategies |
| Distr_Division | Recognize.Data.RuleId |
| Distr_Times | Recognize.Data.RuleId |
| Div | Recognize.Data.Op |
| div4C | Task.MagicTrick.Assess |
| divBase | Domain.Math.Power.Rules |
| divide | Domain.Math.Data.MultivariatePolynomial |
| divideCommonFactor | Domain.Math.Polynomial.Balance |
| Division | Recognize.Data.RuleId |
| divisionDenominator | Domain.Math.Numeric.Rules |
| divisionExpr | Domain.Math.Polynomial.LeastCommonMultiple |
| divisionIsOne | Domain.Math.Polynomial.RationalRules |
| divisionIsZero | Domain.Math.Polynomial.RationalRules |
| divisionNegateLeft | Domain.Math.Numeric.Rules |
| divisionNegateRight | Domain.Math.Numeric.Rules |
| divisionNumerator | Domain.Math.Numeric.Rules |
| divisionRule | Domain.Math.Equation.BalanceRules |
| divisionToFraction | Domain.Math.Polynomial.Balance |
| dnfStrategy | Domain.Logic.Strategies |
| doubleNegate | Domain.Math.Numeric.Rules |
| doubleRoundedView | Recognize.Expr.Normalform |
| dropParensString | Task.MagicTrick.Recognizer |
| dropTable | Database.Data |
| dropUntil | Domain.Math.Power.Utils |
| eliminate | Bayes.Factor |
| eliminateImplEquiv | Domain.Logic.Strategies |
| eliminateList | Bayes.Factor |
| eliminateSplit | Bayes.Factor |
| EliminationOrdering | Bayes.EliminationOrdering |
| Empty | Recognize.Data.DiagnoseError |
| empty | Util.TableData |
| emptyConcepts | Bayes.Script |
| EN | Recognize.Data.Solution |
| enclose | Recognize.Preprocessing |
| Entry | |
| 1 (Type/Class) | Recognize.Data.Entry |
| 2 (Data Constructor) | Recognize.Data.Entry |
| entry | |
| 1 (Function) | Domain.LinearAlgebra.Matrix |
| 2 (Function) | Service.Types |
| eqComAssoc | Util.Expr |
| eqMatrix | Domain.LinearAlgebra.Matrix |
| equalFactors | Domain.Math.Polynomial.LeastCommonMultiple |
| equalLogicA | Domain.Logic.Generator |
| equalLogicACI | Domain.Logic.Generator |
| Equation | Recognize.SubExpr.SEParser |
| equationSolvedForm | Domain.Math.Equation.Views |
| equationSolvedWith | Domain.Math.Equation.Views |
| equationsSolvedForm | Domain.Math.Equation.Views |
| equivalentStructure | Recognize.Expr.Functions |
| eqView | |
| 1 (Function) | Domain.Logic.Utils |
| 2 (Function) | Domain.Math.Power.Utils |
| 3 (Function) | Domain.Math.Polynomial.BalanceUtils |
| EvBuilder | Recognize.Model.EvidenceBuilder |
| Evidence | Bayes.Evidence |
| evidence | Recognize.Data.DiagnoseResult |
| evidenceIndex | Bayes.Evidence |
| evidenceMap | Bayes.Evidence |
| evidenceOfAbsence | Bayes.Evidence |
| EvidenceType | Bayes.Evidence |
| evStates | Bayes.Evidence |
| ex | Domain.Math.Data.MultivariatePolynomial |
| examinator | Service.Types |
| exercise | Service.Types |
| exhaustiveSomewhere | Domain.Math.Power.Utils |
| exhaustiveStrategy | Domain.Math.Power.Utils |
| exhaustiveUse | Domain.Math.Power.Utils |
| exists | Recognize.Model.Connectives |
| exists1 | Recognize.Model.Connectives |
| existsF | Recognize.Model.Connectives |
| existsF1 | Recognize.Model.Connectives |
| Expand | Recognize.Data.Attribute |
| expandExamples | Domain.Math.Polynomial.Examples |
| expandOps | Task.MagicTrick.Recognizer |
| expectation | Database.HumanAssessment |
| expectedAbsence | Database.HumanAssessment |
| expectedPresence | Database.HumanAssessment |
| expo | Domain.Math.Data.MultivariatePolynomial |
| exposeSameFactor | Domain.Math.Polynomial.Rules |
| Expr | Recognize.SubExpr.SEParser |
| expr | Recognize.Parsing.MathParser |
| extract | Recognize.Parsing.MathLexer |
| extractMatched | Recognize.SubExpr.Functions |
| extraIneqQuad | Domain.Math.Polynomial.Examples |
| Factor | Bayes.Factor |
| factor1Ref | Domain.Math.Polynomial.BalanceUtils |
| factor2Ref | Domain.Math.Polynomial.BalanceUtils |
| factorAsPower | Domain.Math.Power.Rules |
| factorizeExamples | Domain.Math.Polynomial.Examples |
| factorLeftAsSquare | Domain.Math.Polynomial.Rules |
| factorRef | Domain.Math.Polynomial.BalanceUtils |
| Factors | Domain.Math.Data.MultivariatePolynomial |
| factorVariablePower | Domain.Math.Polynomial.Rules |
| failOnAnyMistake | Recognize.Model.Assess |
| failOnAtomMixedUpAny | Recognize.Model.Assess |
| failOnCommonMistake | Recognize.Model.Assess |
| failOnIncorrectDistribution | Recognize.Model.Assess |
| failOnInvalidEquation | Recognize.Model.Assess |
| failOnInvalidEquationAny | Recognize.Model.Assess |
| failOnUnequalRelation | Recognize.Model.Assess |
| failOnUnequalRelationAny | Recognize.Model.Assess |
| Failure | Recognize.Model.Result |
| failure | Recognize.Model.Connectives |
| fallback | Main.Report |
| few | Recognize.Parsing.Derived |
| fillInMissedSteps | Task.MagicTrick.Recognizer |
| filterEvidence | Bayes.Evidence |
| filterNodes | Bayes.Network |
| FinalAnswer | Recognize.Data.Attribute |
| finalRecords | Database.Data |
| findEvidence | Bayes.Script |
| findNode | Bayes.Network |
| findNodeFuzzy | Bayes.Network |
| findProbability | Bayes.Evidence |
| findStates | Bayes.Network |
| findTask | Main.Tasks |
| findTaskFuzzy | Main.Tasks |
| findWithDefault | Database.Data |
| flipEquation | Domain.Math.Polynomial.Rules |
| flipOp | Domain.Math.Equation.CoverUpRules |
| flipped | Domain.Math.Polynomial.Balance |
| floorExpr | Recognize.Expr.Normalform |
| Forget | Recognize.Data.Attribute |
| ForgetSym | Recognize.Data.Attribute |
| formExpr | Recognize.Data.Op |
| forward | Domain.LinearAlgebra.Matrix |
| FR | Recognize.Data.Solution |
| fractionPlus | |
| 1 (Function) | Domain.Math.Numeric.Rules |
| 2 (Function) | Domain.Math.Polynomial.RationalRules |
| fractionPlusScale | Domain.Math.Numeric.Rules |
| fractionProduct | Domain.Math.Polynomial.Rules |
| fractionScale | Domain.Math.Polynomial.RationalRules |
| fractionStrategy | Recognize.Strategy.Strategies |
| fractionTimes | Domain.Math.Numeric.Rules |
| fractionTimesCancelDenNom | Domain.Math.Numeric.Rules |
| fractionTimesCancelNomDen | Domain.Math.Numeric.Rules |
| fromDefinition | Recognize.Data.Definition |
| fromDerivation | Recognize.Strategy.Derivation |
| fromDimensions | Bayes.Factor |
| fromDouble | Bayes.Probability |
| fromEvidence | Bayes.Evidence |
| fromEvidenceTp | Bayes.Evidence |
| fromFactors | Domain.Math.Data.MultivariatePolynomial |
| fromList | Util.TableData |
| fromMultivariatePolynomial | Domain.Math.Data.MultivariatePolynomial |
| fromOp | Recognize.Data.Op |
| fromOp' | Recognize.Data.Op |
| fromOps | Recognize.Data.Op |
| fromProbabilities | Bayes.Evidence |
| fromRule | Recognize.Strategy.Derivation |
| fullNetwork | Main.Tasks |
| fullyExpanded | Task.MagicTrick.Assess |
| Function | Domain.Math.Approximation |
| functionCallSymbol | Recognize.Data.Math |
| functionCallWhitelist | Recognize.Data.MathParserOptions |
| Generalizing | Recognize.Data.Approach |
| generalRuleDeMorganAnd | Domain.Logic.GeneralizedRules |
| generalRuleDeMorganOr | Domain.Logic.GeneralizedRules |
| generalRuleDistrAnd | Domain.Logic.GeneralizedRules |
| generalRuleDistrOr | Domain.Logic.GeneralizedRules |
| generalRuleInvDoubleNegAnd | Domain.Logic.GeneralizedRules |
| generalRuleInvDoubleNegOr | Domain.Logic.GeneralizedRules |
| generateEvidence | Recognize.Model.Assess |
| generateLevel | Domain.Logic.Generator |
| generateLogic | Domain.Logic.Generator |
| get | |
| 1 (Function) | Recognize.SubExpr.SEParser |
| 2 (Function) | Util.TableData |
| getAttributes | Recognize.Data.Step, Recognize.Data.Diagnosis |
| getAttributesPerStep | Recognize.Model.EvidenceBuilder |
| getBinary | Recognize.Parsing.Derived |
| getChainedEq | Recognize.Data.Math |
| getConstraint | Recognize.Model.Constraint |
| getEq | Recognize.Data.Math |
| getEqE | Recognize.Data.Math |
| getEvidence | Database.HumanAssessment |
| getExercise | Recognize.Data.MathStoryProblem |
| getExpr | Recognize.Data.Math |
| getFactors | Bayes.Inference |
| getHumanMachineFiles | Database.HumanAssessment |
| getIndex | Bayes.Evidence |
| getInput | Recognize.Data.Solution |
| getInputId | Recognize.Data.Solution |
| getInputSize | Recognize.Parsing.Derived |
| getLeft | Recognize.Expr.Functions |
| getMatched | Recognize.SubExpr.Functions |
| getMatchEnvironment | Recognize.Parsing.Interpretation |
| getMath | Recognize.Data.Step, Recognize.Data.Diagnosis |
| getMaths | Recognize.Data.Step, Recognize.Data.Diagnosis |
| getMostLeft | Recognize.Expr.Functions |
| getNames | Bayes.Evidence |
| getNode | Recognize.Model.Constraint |
| getRelation | Recognize.Data.Math |
| getRelationE | Recognize.Data.Math |
| getResult | |
| 1 (Function) | Recognize.Model.Constraint |
| 2 (Function) | Recognize.Data.Math |
| getRight | Recognize.Expr.Functions |
| gets | Recognize.SubExpr.SEParser |
| getSpreadsheet | Database.HumanAssessment |
| getString | Recognize.Data.Math |
| getTranslations | Bayes.StudentReport |
| getValue | Recognize.Data.Step |
| getValueOf | Recognize.Model.EvidenceBuilder |
| getVar | Recognize.Expr.Functions |
| getVariables | Recognize.Model.EvidenceBuilder |
| getVarKey | Recognize.SubExpr.SEParser |
| getVarS | Recognize.Expr.Functions |
| getWildcard | Recognize.Parsing.Interpretation |
| giveNode | Recognize.Model.Constraint |
| giveNodeAndCollect | Recognize.Model.Assess |
| giveNodeAndCollectAll | Recognize.Model.Assess |
| giveNodeAndCollectAllKnown | Recognize.Model.Assess |
| giveNodeAndCollectDefault | Recognize.Model.Assess |
| Graphical | Recognize.Data.Approach |
| groupAbsorption | Domain.Logic.Utils |
| groupAssociativity | Domain.Logic.Utils |
| groupBy' | Util.List |
| groupCommutativity | Domain.Logic.Utils |
| groupDeMorgan | Domain.Logic.Utils |
| groupDistribution | Domain.Logic.Utils |
| groupDoubleNegation | Domain.Logic.Utils |
| groupEquivalence | Domain.Logic.Utils |
| groupFalseComplement | Domain.Logic.Utils |
| groupFalseConjunction | Domain.Logic.Utils |
| groupFalseDisjunction | Domain.Logic.Utils |
| GroupId | Recognize.Data.Solution |
| groupId | Recognize.Data.Solution |
| groupIdempotency | Domain.Logic.Utils |
| groupImplication | Domain.Logic.Utils |
| groupings | Util.List |
| groupNotFalse | Domain.Logic.Utils |
| groupNotTrue | Domain.Logic.Utils |
| groupTrueComplement | Domain.Logic.Utils |
| groupTrueConjunction | Domain.Logic.Utils |
| groupTrueDisjunction | Domain.Logic.Utils |
| growF | Recognize.SubExpr.SEParser |
| guardBy | Recognize.Parsing.Parse |
| guessMagicExpr | Task.MagicTrick.Recognizer |
| HalfPerimeter | Recognize.Data.Attribute |
| hardEvidence | Bayes.Evidence |
| HasApproach | Recognize.Data.Approach |
| hasChainedEquations | Recognize.Data.MathParserOutput |
| hasCommonality | Task.MagicTrick.Recognizer |
| hasExpr | Recognize.Expr.Functions |
| hasMagicNat | Recognize.SubExpr.Functions |
| hasMagicNumber | Recognize.SubExpr.Functions |
| hasMagicVar | Recognize.SubExpr.Functions |
| hasMatch | Recognize.SubExpr.Functions |
| hasMistakes | Recognize.Data.Step, Recognize.Data.Diagnosis |
| hasSub | Recognize.SubExpr.Functions |
| hasVar | |
| 1 (Function) | Recognize.SubExpr.Functions |
| 2 (Function) | Recognize.Expr.Functions |
| hasVarD | Bayes.Factor |
| header | Main.Report |
| higherDegreeEquationsView | Domain.Math.Polynomial.Views |
| higherDegreeExamples | Domain.Math.Polynomial.Examples |
| higherSubst | Domain.Math.Polynomial.Rules |
| holes | Domain.Math.Power.Utils |
| htmlTable | Util.TableData |
| identity | Domain.LinearAlgebra.Matrix |
| identityMatrix | Domain.LinearAlgebra.Matrix |
| ids | Service.Types |
| implication | Recognize.Model.Connectives |
| Implicit | Recognize.Data.Attribute |
| IncorrectDistribution | Recognize.Data.Attribute |
| IncorrectFactorization | Recognize.Data.Attribute |
| indent | Util.String |
| Index | Bayes.Evidence |
| index | Util.List |
| ineqHigh | Domain.Math.Polynomial.Examples |
| ineqLin1 | Domain.Math.Polynomial.Examples |
| ineqQuad1 | Domain.Math.Polynomial.Examples |
| ineqQuad2 | Domain.Math.Polynomial.Examples |
| InequalityStrictness | Recognize.Data.Attribute |
| infer | Bayes.Inference |
| inferEvidence | Bayes.Inference |
| inferNetwork | Bayes.Inference |
| initialState | Recognize.Parsing.Interpretation |
| inLiberalEquationMode | Recognize.Parsing.Interpretation |
| Input | |
| 1 (Type/Class) | Recognize.Data.Solution |
| 2 (Data Constructor) | Recognize.Data.Solution |
| inputFile | Recognize.Data.MathStoryProblem |
| InputID | Database.Data |
| InputId | Recognize.Data.Solution |
| inputs | Recognize.Data.Solution |
| inputToString | Recognize.Data.Solution |
| InputType | Recognize.SubExpr.SEParser |
| inputType | Recognize.SubExpr.SEParser |
| inRowEchelonForm | Domain.LinearAlgebra.Matrix |
| inRowReducedEchelonForm | Domain.LinearAlgebra.Matrix |
| insert | Database.Data |
| insertRecord | Database.Data |
| insertRecords | Database.Data |
| integerGenerator | Domain.Math.Numeric.Generators |
| interpret | Recognize.Parsing.Interpretation |
| Interpretation | Recognize.Parsing.Interpretation |
| InterpretationParser | Recognize.Parsing.Interpretation |
| introFalse | Domain.Math.Polynomial.Balance |
| introTrue | Domain.Math.Polynomial.Balance |
| InvalidCommutativity | Recognize.Data.Attribute |
| InvalidEquation | Recognize.Data.Attribute |
| inverse | Domain.LinearAlgebra.Matrix |
| inverseAndOverOr | Domain.Logic.InverseRules |
| inverseDeMorganAnd | Domain.Logic.InverseRules |
| inverseDeMorganOr | Domain.Logic.InverseRules |
| inverseIdempAnd | Domain.Logic.InverseRules |
| inverseIdempOr | Domain.Logic.InverseRules |
| inverseOrOverAnd | Domain.Logic.InverseRules |
| inverseRules | Domain.Logic.InverseRules |
| InvertedFraction | Recognize.Data.Attribute |
| invertible | Domain.LinearAlgebra.Matrix |
| isAnd | Recognize.SubExpr.Functions |
| isAndSymbol | Recognize.SubExpr.Functions |
| isApproximation | Recognize.Data.Attribute |
| isAtom | Recognize.Expr.Functions |
| isBuggy | Recognize.SubExpr.Functions |
| isBuggySymbol | Recognize.SubExpr.Functions |
| isChainedEq | Recognize.Data.Math |
| isChainedEqSymbol | Recognize.Data.Math |
| isCommonMistake | Recognize.Data.Attribute |
| isDefinition | Recognize.Data.Math |
| isDiv | Recognize.Expr.Functions |
| isEmpty | |
| 1 (Function) | Domain.LinearAlgebra.Matrix |
| 2 (Function) | Bayes.Evidence |
| isEq | Recognize.Data.Math |
| isFunctionCall | Recognize.Data.Math |
| isFunctionCallSymbol | Recognize.Data.Math |
| isFunctionDefinition | Recognize.Data.Math |
| isLabel | Recognize.SubExpr.Functions |
| isLabelAttr | Recognize.Data.Attribute |
| isLabelSymbol | Recognize.SubExpr.Functions |
| isLiteral | Util.Expr |
| isLowerTriangular | Domain.LinearAlgebra.Matrix |
| isLt | Recognize.SubExpr.Functions |
| isLtSymbol | Recognize.SubExpr.Functions |
| isMagicNat | Recognize.SubExpr.Functions |
| isMagicNatSymbol | Recognize.SubExpr.Functions |
| isMagicNumber | Recognize.SubExpr.Functions |
| isMagicNumberSymbol | Recognize.SubExpr.Functions |
| isMagicVar | Recognize.SubExpr.Functions |
| isMagicVarSymbol | Recognize.SubExpr.Functions |
| isMatch | Recognize.SubExpr.Functions |
| isMatched | Recognize.SubExpr.Functions |
| isMatchSymbol | Recognize.SubExpr.Functions |
| isMistake | Recognize.Data.Attribute |
| isNamedWildcardSymbol | Recognize.Expr.Symbols |
| isNat | Recognize.Expr.Functions |
| isNormalformSymbol | Recognize.Expr.Symbols |
| isNoSim | Recognize.SubExpr.Functions |
| isNoSimSymbol | Recognize.SubExpr.Functions |
| isNumber | Recognize.Expr.Functions |
| isOr | Recognize.SubExpr.Functions |
| isOrSymbol | Recognize.SubExpr.Functions |
| isParseError | Recognize.Data.Math |
| isPivotColumn | Domain.LinearAlgebra.Matrix |
| isPlusT | Domain.Math.Polynomial.BalanceUtils |
| isRectangular | Domain.LinearAlgebra.Matrix |
| isSim | Recognize.SubExpr.Functions |
| isSimplified | Recognize.SubExpr.Functions |
| isSimSymbol | Recognize.SubExpr.Functions |
| isSquare | Domain.LinearAlgebra.Matrix |
| isStepN1 | Task.Matryoshka.Assess |
| isStepN2a | Task.Matryoshka.Assess |
| isStepN2b | Task.Matryoshka.Assess |
| isStop | Recognize.SubExpr.Functions |
| isStopSymbol | Recognize.SubExpr.Functions |
| isSub | Recognize.SubExpr.Functions |
| isSubExprOf | |
| 1 (Function) | Util.Expr |
| 2 (Function) | Recognize.SubExpr.Functions |
| isSubSymbol | Recognize.SubExpr.Functions |
| isTimesT | Domain.Math.Polynomial.BalanceUtils |
| isUnknown | Recognize.Model.Result |
| isUpperTriangular | Domain.LinearAlgebra.Matrix |
| isVar | |
| 1 (Function) | Recognize.SubExpr.Functions |
| 2 (Function) | Recognize.Expr.Functions |
| isVarSymbol | Recognize.SubExpr.Functions |
| isWildcardSymbol | Recognize.Expr.Symbols |
| joinBy | Domain.Math.Power.Utils |
| Label | Recognize.Data.Attribute |
| label | Bayes.Network |
| label2state | Bayes.Network |
| LabelE | Recognize.Data.Attribute |
| labelSymbol | Recognize.SubExpr.Symbols |
| lang | Service.Types |
| Language | Recognize.Data.Solution |
| language | Recognize.Data.Solution |
| latestEvidence | Database.Data |
| latestInsertRowID | Database.Data |
| latestPartialModels | Database.Data |
| latestRecord | Database.Data |
| latestStudentModel | Database.Data |
| latestStudentReport | Database.Data |
| Layout | Bayes.SVG |
| layout | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.TheatreRate |
| 3 (Function) | Task.Network.StudentModel |
| 4 (Function) | Task.Network.RectangleArea |
| 5 (Function) | Task.Network.Pattern |
| 6 (Function) | Task.Network.Matryoshka |
| 7 (Function) | Task.Network.MakingASquare |
| 8 (Function) | Task.Network.MagicTrick |
| 9 (Function) | Task.Network.CarRental |
| 10 (Function) | Task.Network.AreaOfATriangle |
| 11 (Function) | Task.Network.AreaAndExpression |
| LayoutMode | Recognize.Data.StringLexer |
| layoutMode | Recognize.Data.StringLexer |
| lbl | Recognize.SubExpr.Symbols |
| lblE | Recognize.SubExpr.Symbols |
| lcmExpr | Domain.Math.Polynomial.LeastCommonMultiple |
| lexer | Recognize.Data.MathStoryProblem |
| LexerOutput | |
| 1 (Type/Class) | Recognize.Data.StringLexer |
| 2 (Data Constructor) | Recognize.Data.StringLexer |
| lexerOutput | Recognize.Data.DiagnoseResult |
| liftRule | Recognize.Strategy.Rules |
| liftS | Domain.Math.Simplification |
| liftS2 | Domain.Math.Simplification |
| limitNesting | Bayes.StudentReport |
| linbal | Domain.Math.Polynomial.BalanceUtils |
| Linear | Recognize.SubExpr.SEParser |
| linearEquationView | Domain.Math.Polynomial.Views |
| linearExamples | Domain.Math.Polynomial.Examples |
| linearGen | Domain.Math.Polynomial.Generators |
| linearPolyView | Domain.Math.Polynomial.Views |
| linearView | Domain.Math.Polynomial.Views |
| linearViewWith | Domain.Math.Polynomial.Views |
| LinearWithType | Recognize.SubExpr.SEParser |
| listOfPowerFactors | Domain.Math.Polynomial.Views |
| locNode | Database.HumanAssessment |
| locStudent | Database.HumanAssessment |
| locTask | Database.HumanAssessment |
| logarithm | Domain.Math.Power.Rules |
| logView | Domain.Math.Power.Views |
| lt | Recognize.SubExpr.Symbols |
| ltSymbol | Recognize.SubExpr.Symbols |
| M | Recognize.Data.Math |
| magicNatSymbol | Recognize.SubExpr.Symbols |
| magicNumberSymbol | Recognize.SubExpr.Symbols |
| magicTrick | Task.MagicTrick.Recognizer |
| magicVarSymbol | Recognize.SubExpr.Symbols |
| makeFactor | Bayes.Factor |
| makeFAStep | Recognize.Data.Step, Recognize.Data.Diagnosis |
| makeInvRule | Domain.Logic.Utils |
| makeInvRuleWithUse | Domain.Logic.Utils |
| makeListRule | Domain.Logic.Utils |
| makeMath | Recognize.Data.Math |
| makeMatrix | Domain.LinearAlgebra.Matrix |
| makeNetwork | Bayes.Network |
| makeNodeConstraint | Recognize.Model.Constraint |
| makePage | Util.W3CSSHTML |
| makeProbabilities | Bayes.Evidence |
| makeSimpleRule | Domain.Logic.Utils |
| makingASquare | Task.MakingASquare |
| many' | Recognize.Parsing.Derived |
| many1 | Recognize.Parsing.Derived |
| many1' | Recognize.Parsing.Derived |
| mapGerman | Recognize.Preprocessing |
| mapNodes | Bayes.Network |
| mapNodesM | Bayes.Network |
| mapWithPos | Domain.LinearAlgebra.Matrix |
| Match | |
| 1 (Type/Class) | Database.HumanAssessment |
| 2 (Data Constructor) | Database.HumanAssessment |
| matchAbsence | Database.HumanAssessment |
| MatchedBy | Recognize.Data.Attribute |
| matchExpr | Recognize.SubExpr.Symbols |
| matchings | Recognize.SubExpr.SEParser |
| matchLin | Domain.Math.Polynomial.BalanceUtils |
| matchPlusCon | Domain.Math.Polynomial.BalanceUtils |
| matchPredicate | Recognize.SubExpr.SEParser |
| matchRuleId | Recognize.Data.RuleId |
| matchState | Database.HumanAssessment |
| matchSymbol | Recognize.SubExpr.Symbols |
| Math | Recognize.Data.Math |
| mathListHtml | Recognize.Data.Math |
| MathParseError | |
| 1 (Type/Class) | Recognize.Data.Math |
| 2 (Data Constructor) | Recognize.Data.Math |
| mathParser | Recognize.Data.MathParserOutput |
| MathParserOptions | Recognize.Data.MathParserOptions |
| mathParserOptions | Recognize.Data.MathParserOptions |
| MathParserOutput | |
| 1 (Type/Class) | Recognize.Data.MathParserOutput |
| 2 (Data Constructor) | Recognize.Data.MathParserOutput |
| mathParserOutput | Recognize.Data.MathParserOutput |
| MathStoryProblem | Recognize.Data.MathStoryProblem |
| mathStoryProblem | Recognize.Data.MathStoryProblem |
| Matrix | Domain.LinearAlgebra.Matrix |
| matryoshka | Task.Matryoshka.Recognizer |
| maybeToParse | Recognize.Parsing.Derived |
| merge | Domain.Math.Polynomial.Rules |
| mergeAlike | Domain.Math.Simplification |
| mergeAlikeProduct | Domain.Math.Simplification |
| mergeAlikeSum | Domain.Math.Simplification |
| mergeConstants | Domain.Math.Power.Utils |
| mergeConstantsWith | Domain.Math.Power.Utils |
| mergeNums | Recognize.Strategy.Rules |
| mergesD | Bayes.Factor |
| mergeSteps | Recognize.Data.Step, Recognize.Data.Diagnosis |
| mergeVars | Recognize.Strategy.Rules |
| minFactorOrder | Bayes.EliminationOrdering |
| minFactorVars | Bayes.EliminationOrdering |
| minusNegateLeft | Domain.Math.Numeric.Rules |
| minusNegateRight | Domain.Math.Numeric.Rules |
| minusRule | Domain.Math.Equation.BalanceRules |
| minusView | Domain.Math.Polynomial.BalanceUtils |
| Misconception | Recognize.Data.Attribute |
| mismatchState | Database.HumanAssessment |
| mkNoisyAdder | Bayes.NodeTypes |
| mkNoisyAdder2 | Bayes.NodeTypes |
| mkNoisyOr | Bayes.NodeTypes |
| mkSum | Domain.Math.Data.MultivariatePolynomial |
| modify | Recognize.SubExpr.SEParser |
| modifyAt | Util.List |
| monomialPolyView | Domain.Math.Polynomial.Views |
| moveToLeft | Domain.Math.Polynomial.Rules |
| MParser | Recognize.Parsing.MathParser |
| Mul | Recognize.Data.Op |
| mul3C | Task.MagicTrick.Assess |
| mulExponents | Domain.Math.Power.Rules |
| multByConcatenation | Recognize.Data.MathParserOptions |
| multiply | |
| 1 (Function) | Bayes.Factor |
| 2 (Function) | Domain.LinearAlgebra.Matrix |
| multiplyOneDiv | Domain.Math.Polynomial.RationalRules |
| MultivariatePolynomial | Domain.Math.Data.MultivariatePolynomial |
| multivariatePolynomialToMap | Domain.Math.Data.MultivariatePolynomial |
| multivariatePolynomialView | Domain.Math.Data.MultivariatePolynomial |
| multivariatePolynomialViewWith | Domain.Math.Data.MultivariatePolynomial |
| mulZero | Domain.Math.Polynomial.Rules |
| mWhen | Util.Monad |
| myFractionTimes | Domain.Math.Power.Rules |
| myIntegerView | Domain.Math.Power.Utils |
| name | Bayes.Network |
| namedWildcard | Recognize.Expr.Symbols |
| namedWildcardSymbol | Recognize.Expr.Symbols |
| naturalRules | Domain.Math.Power.Utils |
| negate | Recognize.Model.Result |
| negateBothSides | Domain.Math.Polynomial.Balance |
| negateConstraint | Recognize.Model.Connectives |
| negateMV | Domain.Math.Data.MultivariatePolynomial |
| negateZero | Domain.Math.Numeric.Rules |
| negView | Domain.Math.Polynomial.BalanceUtils |
| nestRight | Recognize.Data.Op |
| Network | Bayes.Network |
| network | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.TheatreRate |
| 3 (Function) | Task.Network.StudentModel |
| 4 (Function) | Task.Network.RectangleArea |
| 5 (Function) | Task.Network.Pattern |
| 6 (Function) | Task.Network.Matryoshka |
| 7 (Function) | Task.Network.MakingASquare |
| 8 (Function) | Task.Network.MagicTrick |
| 9 (Function) | Task.Network.CarRental |
| 10 (Function) | Task.Network.AreaOfATriangle |
| 11 (Function) | Task.Network.AreaAndExpression |
| networkFile | Recognize.Data.MathStoryProblem |
| networkInterface | Bayes.InterfaceWriter |
| networkToHTML | Bayes.SVG |
| networkToSVG | Bayes.SVG |
| newDiagnosis | Recognize.Data.Diagnosis |
| newEvidence | Bayes.Evidence |
| newMagicNat | Recognize.SubExpr.Symbols |
| newMagicNumber | Recognize.SubExpr.Symbols |
| newMagicVar | Recognize.SubExpr.Symbols |
| newton | Domain.Math.Approximation |
| newVar | Recognize.Model.EvidenceBuilder |
| NExpr | Recognize.Data.Attribute |
| nextVariable | Bayes.EliminationOrdering |
| nf | Recognize.Expr.Normalform |
| nf4 | Recognize.Expr.Normalform |
| nfCom | Recognize.Expr.Normalform |
| nfComAssoc | Recognize.Expr.Normalform |
| niceFactors | Domain.Math.Polynomial.Rules |
| niceFactorsNew | Domain.Math.Polynomial.Rules |
| NL | Recognize.Data.Solution |
| nnfStep | Domain.Logic.Strategies |
| NoApproach | Recognize.Data.Approach |
| noCommonFactor | Domain.Math.Polynomial.LeastCommonMultiple |
| Node | |
| 1 (Type/Class) | Bayes.Network |
| 2 (Data Constructor) | Bayes.Network |
| node | Bayes.Network |
| NodeConstraint | |
| 1 (Type/Class) | Recognize.Model.Constraint |
| 2 (Data Constructor) | Recognize.Model.Constraint |
| NodeID | Database.Data |
| nodeId | Bayes.Network |
| nodeIds | Bayes.Network |
| nodeIsSet | Bayes.Evidence |
| nodeNotSet | Bayes.Evidence |
| nodes | Bayes.Network |
| nodeSetTo | Bayes.Evidence |
| node_ | Bayes.Network |
| noDivisionConstant | Domain.Math.Polynomial.Rules |
| NoisyAdder | Bayes.Network |
| NoisyMax | Bayes.Network |
| noLinFormula | Domain.Math.Polynomial.Rules |
| nonEmpty | Recognize.Parsing.Derived |
| NonMatchingParentheses | Recognize.Data.Attribute |
| nonZero | |
| 1 (Function) | Domain.Math.Numeric.Generators |
| 2 (Function) | Domain.LinearAlgebra.Matrix |
| noPars | Task.MagicTrick.Recognizer |
| normalform | Recognize.Expr.Symbols |
| normalformSymbol | Recognize.Expr.Symbols |
| normalize | |
| 1 (Function) | Bayes.Factor |
| 2 (Function) | Util.String |
| 3 (Function) | Recognize.Strategy.Applications |
| 4 (Function) | Main.Diagnose |
| Normalized | Recognize.Data.Attribute |
| normalizeExercise | Recognize.Strategy.Exercises |
| normalizeIfNF | Recognize.Expr.Functions |
| normalizeLogicA | Domain.Logic.Generator |
| normalizeStrategy | Recognize.Strategy.Strategies |
| noSim | Recognize.SubExpr.Symbols |
| noSimSymbol | Recognize.SubExpr.Symbols |
| noVirtuals | Bayes.Evidence |
| nullity | Domain.LinearAlgebra.Matrix |
| NumberRange | Util.NumberRange |
| Numerical | Recognize.Data.Approach |
| numGenerator | Domain.Math.Numeric.Generators |
| observation | Database.HumanAssessment |
| oneF | Domain.Math.Data.MultivariatePolynomial |
| onePower | Domain.Math.Power.Rules |
| oneVar | Domain.Math.Polynomial.Rules |
| Op | Recognize.Data.Op |
| OperatorMixedUp | Recognize.Data.Attribute |
| optGrow | Recognize.SubExpr.SEParser |
| option | Recognize.Parsing.Parse |
| optionNegate | Recognize.Strategy.Views |
| optIterate | Recognize.SubExpr.SEParser |
| optSimplify | Recognize.SubExpr.SEParser |
| optSkipOnce | Recognize.SubExpr.SEParser |
| optTraverse | Recognize.SubExpr.SEParser |
| orderBy | Util.List |
| originalInput | Recognize.Data.DiagnoseResult |
| orRules | Domain.Logic.Strategies |
| orSymbol | Recognize.SubExpr.Symbols |
| orView | |
| 1 (Function) | Domain.Logic.Utils |
| 2 (Function) | Domain.Logic.Views |
| oSkipExpressions | Task.MagicTrick.Recognizer |
| Other | |
| 1 (Data Constructor) | Recognize.Data.Approach |
| 2 (Data Constructor) | Recognize.Data.Attribute |
| oTryManyBuggyPars | Task.MagicTrick.Recognizer |
| outCategories | Main.Diagnose |
| outDiagnose | Main.Diagnose |
| pAnnounce | Task.MagicTrick.Recognizer |
| pAnyExpr | Recognize.Parsing.Derived |
| pAnyOf | Recognize.Parsing.Derived |
| pAnywhere | Recognize.Parsing.Derived |
| parenthesisMismatch | Recognize.Data.Diagnosis |
| parentIds | Bayes.Network |
| parents | Bayes.Network |
| Parse | Recognize.Parsing.Parse |
| parseColumns | Recognize.Parsing.MathLexer |
| parseConsequence | Domain.Logic.Parser |
| ParseLog | Recognize.Parsing.Parse |
| parseLogic | Domain.Logic.Parser |
| parseLogicPars | Domain.Logic.Parser |
| parseLogicProof | Domain.Logic.Parser |
| parseLogicProofs | Domain.Logic.Parser |
| parseLogicUnicodePars | Domain.Logic.Parser |
| parseMath | Recognize.Parsing.MathParser |
| Parser | Recognize.Parsing.Parser |
| parser | Recognize.Data.MathStoryProblem |
| parserOutput | Recognize.Data.DiagnoseResult |
| ParserT | Recognize.Parsing.Parser |
| parseSimple | Recognize.Parsing.MathLexer |
| parseSimple' | Recognize.Parsing.MathParser |
| parseStatement | Domain.Logic.Parser |
| PartialMatch | Recognize.Data.Attribute |
| pAttempts | Task.MagicTrick.Recognizer |
| pAttempts1 | Task.MagicTrick.Recognizer |
| pattern | Task.Pattern.Recognizer |
| payload | Recognize.Data.Diagnosis |
| pBuggyStep | Task.MagicTrick.Recognizer |
| pCompare | Recognize.SubExpr.Compare |
| pCompareByNormalize | Recognize.SubExpr.Compare |
| pCompareBySimplify | Recognize.SubExpr.Compare |
| pConclude | Task.MagicTrick.Recognizer |
| pDiagnosis | Task.MagicTrick.Recognizer |
| peek | Recognize.Parsing.Derived |
| peek2 | Recognize.Parsing.Derived |
| peekEq | Recognize.Parsing.Derived |
| peekExpr | Recognize.Parsing.Derived |
| pEq | Recognize.Parsing.Derived |
| pEqCom | Recognize.Parsing.Derived |
| pEqWith | Task.MagicTrick.Recognizer |
| pEqWith2 | Task.MagicTrick.Recognizer |
| pEqWithL | Task.MagicTrick.Recognizer |
| perc | Main.Diagnose |
| percentage | |
| 1 (Function) | Util.String |
| 2 (Function) | Util.Table |
| percPar | Main.Diagnose |
| Perimeter | Recognize.Data.Attribute |
| pExercise | Recognize.Strategy.Recognizer |
| pExplicitSimplifyEq | Task.MagicTrick.Recognizer |
| pExplicitSimplifyExpr | Task.MagicTrick.Recognizer |
| pExpr | Recognize.Parsing.Derived |
| pExprCom | Recognize.Parsing.Derived |
| pExprWith | Recognize.Parsing.Derived |
| pFixEqCom | Task.MagicTrick.Recognizer |
| pFixExprCom | Task.MagicTrick.Recognizer |
| pFoldAlt | Recognize.Parsing.Derived |
| pIf | Task.MagicTrick.Recognizer |
| PilotID | Database.Data |
| pInOrder | Recognize.Parsing.Derived |
| pInOrderAll | Recognize.Parsing.Derived |
| pivot | Domain.LinearAlgebra.Matrix |
| plainNatView | Domain.Math.Power.Utils, Domain.Math.Power.Views |
| plainRationalView | Domain.Math.Power.Utils, Domain.Math.Power.Views |
| pLog | Recognize.Parsing.Parse |
| plus | Domain.Math.Data.MultivariatePolynomial |
| plusNegateLeft | Domain.Math.Numeric.Rules |
| plusNegateRight | Domain.Math.Numeric.Rules |
| plusRule | Domain.Math.Equation.BalanceRules |
| pMagicExpr | Task.MagicTrick.Recognizer |
| pMatchEq | Task.MagicTrick.Recognizer |
| pMatchExpr | Task.MagicTrick.Recognizer |
| pMatchSubSteps | Recognize.SubExpr.Recognizer |
| pNamedStep | Recognize.Parsing.Interpretation |
| pNextStepBuggyPars | Task.MagicTrick.Recognizer |
| Point | Bayes.SVG |
| pointX | Bayes.SVG |
| pointY | Bayes.SVG |
| polynomialDegreeGen | Domain.Math.Polynomial.Generators |
| polynomialGen | Domain.Math.Polynomial.Generators |
| polyNormalForm | Domain.Math.Polynomial.Views |
| polyRelaxedForm | Domain.Math.Polynomial.Views |
| polyView | Domain.Math.Polynomial.Views |
| polyViewWith | Domain.Math.Polynomial.Views |
| Power | Recognize.Data.RuleId |
| power2root | Domain.Math.Power.Rules |
| powerFactorView | |
| 1 (Function) | Domain.Math.Power.OldViews |
| 2 (Function) | Domain.Math.Power.Views |
| powerFactorViewForWith | Domain.Math.Power.OldViews |
| powerFactorViewWith | Domain.Math.Power.OldViews |
| powerOne | Domain.Math.Power.Rules |
| powerProductView | Domain.Math.Polynomial.LeastCommonMultiple |
| powerView | Domain.Math.Power.Views |
| powerViewFor | Domain.Math.Power.Views |
| powerViewWith | Domain.Math.Power.Views |
| powerZero | Domain.Math.Power.Rules |
| ppExpr | Recognize.Data.Math |
| ppLogicPars | Domain.Logic.Parser |
| ppLogicUnicodePars | Domain.Logic.Parser |
| precision | |
| 1 (Function) | Domain.Math.Approximation |
| 2 (Function) | Recognize.SubExpr.SEParser |
| predicateCombined | Domain.Math.Equation.CoverUpRules |
| predicateCovered | Domain.Math.Equation.CoverUpRules |
| prepareSplitSquare | Domain.Math.Polynomial.Rules |
| pRepeat | Recognize.Parsing.Derived |
| pReplicate | Recognize.Parsing.Derived |
| preProcess | Recognize.Preprocessing |
| prettyMap | Util.Pretty |
| prettyMatches | Database.HumanAssessment |
| pRewrite | Recognize.Parsing.Derived |
| printCache | Util.Cache |
| printMath | Recognize.Data.Math |
| Prior | |
| 1 (Type/Class) | Database.Priors |
| 2 (Data Constructor) | Database.Priors |
| Priors | |
| 1 (Type/Class) | Database.Priors |
| 2 (Data Constructor) | Database.Priors |
| Probabilities | Bayes.Evidence |
| probabilitiesFor | Bayes.Evidence |
| Probability | Bayes.Probability |
| probHigh | Task.MagicTrick.Recognizer |
| problemId | Recognize.Data.MathStoryProblem |
| probLow | Task.MagicTrick.Recognizer |
| probMediumLow | Task.MagicTrick.Recognizer |
| processInputs | Recognize.Data.MathStoryProblem |
| Product | Domain.Math.Data.MultivariatePolynomial |
| propositionalId | Domain.Logic.Utils |
| pruneNetwork | Bayes.Inference |
| pSkipUntil | Recognize.Parsing.Derived |
| pSolveLinear | Recognize.Strategy.Applications |
| pSomewhere | Recognize.Parsing.Derived |
| pStdDiagnosis | Task.MagicTrick.Recognizer |
| pStep | |
| 1 (Function) | Recognize.Parsing.Interpretation |
| 2 (Function) | Task.MagicTrick.Recognizer |
| pStepEq | Recognize.Parsing.Interpretation |
| pStepEquation | Task.MagicTrick.Recognizer |
| pStepErr | Task.MagicTrick.Recognizer |
| pStepError | Task.MagicTrick.Recognizer |
| pStepExpr | Task.MagicTrick.Recognizer |
| pStepForget | Task.MagicTrick.Recognizer |
| pStepIneq | Recognize.Parsing.Interpretation |
| pStepOperators | Task.MagicTrick.Recognizer |
| pStepsFor | Task.MagicTrick.Recognizer |
| pStepSimplify | Task.MagicTrick.Recognizer |
| pStepsPhase1 | Task.MagicTrick.Recognizer |
| pStepsPhase2 | Task.MagicTrick.Recognizer |
| pStepsPhase3 | Task.MagicTrick.Recognizer |
| pStepsPhase4 | Task.MagicTrick.Recognizer |
| pStepStrongIneq' | Recognize.Parsing.Interpretation |
| pSubstituteVars | Recognize.SubExpr.Compare |
| pt | Bayes.SVG |
| pTask | Task.MagicTrick.Recognizer |
| pTaskErr | Task.MagicTrick.Recognizer |
| pTaskForget | Task.MagicTrick.Recognizer |
| pTaskSimplify | Task.MagicTrick.Recognizer |
| pushNegOut | Domain.Math.Power.Rules |
| pushNot | Domain.Logic.Views |
| pushNotWith | Domain.Logic.Views |
| put | Recognize.SubExpr.SEParser |
| putAttributes | Recognize.Model.EvidenceBuilder |
| putVariables | Recognize.Model.EvidenceBuilder |
| pVars | Task.MagicTrick.Recognizer |
| quadraticEquationsView | Domain.Math.Polynomial.Views |
| quadraticEquationView | Domain.Math.Polynomial.Views |
| quadraticExamples | Domain.Math.Polynomial.Examples |
| quadraticGen | Domain.Math.Polynomial.Generators |
| quadraticPolyView | Domain.Math.Polynomial.Views |
| quadraticRuleOrder | Domain.Math.Polynomial.Rules |
| quadraticView | Domain.Math.Polynomial.Views |
| quadraticViewWith | Domain.Math.Polynomial.Views |
| Query | Bayes.Inference |
| quickQueryMap | Database.Data |
| r | Task.Network.StudentModel |
| r1 | Task.Network.StudentModel |
| r11 | Task.Network.StudentModel |
| r11_T02 | Task.Network.CarRental |
| r11_T05 | Task.Network.MagicTrick |
| r11_T10 | Task.Network.Matryoshka |
| r11_T10_P1 | Task.Network.Matryoshka |
| r11_T10_P2 | Task.Network.Matryoshka |
| r12 | Task.Network.StudentModel |
| r121 | Task.Network.StudentModel |
| r1211 | Task.Network.StudentModel |
| r1211_T02 | Task.Network.CarRental |
| r1211_T03 | Task.Network.Pattern |
| r1211_T05 | Task.Network.MagicTrick |
| r1211_T06 | Task.Network.TheatreRate |
| r1211_T10 | Task.Network.Matryoshka |
| r1212 | Task.Network.StudentModel |
| r1212_T02 | Task.Network.RectangleArea |
| r1212_T04 | Task.Network.MakingASquare |
| r1212_T08 | Task.Network.AreaOfATriangle |
| r1212_T09 | Task.Network.AreaAndExpression |
| r1213 | Task.Network.StudentModel |
| r1213_T02 | Task.Network.CarRental |
| r1213_T03 | Task.Network.Pattern |
| r1213_T06 | Task.Network.TheatreRate |
| r1213_T07 | Task.Network.VPattern |
| r1213_T08 | Task.Network.AreaOfATriangle |
| r1214 | Task.Network.StudentModel |
| r1214_T02 | Task.Network.RectangleArea |
| r1214_T04 | Task.Network.MakingASquare |
| r1215 | Task.Network.StudentModel |
| r1215_T10 | Task.Network.Matryoshka |
| r121_T05 | Task.Network.MagicTrick |
| r121_T06 | Task.Network.TheatreRate |
| r12_T02 | |
| 1 (Function) | Task.Network.RectangleArea |
| 2 (Function) | Task.Network.CarRental |
| r12_T03 | Task.Network.Pattern |
| r12_T06 | Task.Network.TheatreRate |
| r12_T08 | Task.Network.AreaOfATriangle |
| r13 | Task.Network.StudentModel |
| r13_T02 | Task.Network.CarRental |
| r13_T03 | Task.Network.Pattern |
| r13_T06 | Task.Network.TheatreRate |
| r3 | Task.Network.StudentModel |
| r31 | Task.Network.StudentModel |
| r31_T02 | Task.Network.CarRental |
| r31_T03 | Task.Network.Pattern |
| r31_T05 | Task.Network.MagicTrick |
| r31_T06 | Task.Network.TheatreRate |
| r31_T10 | Task.Network.Matryoshka |
| r31_T10_P1 | Task.Network.Matryoshka |
| r31_T10_P2 | Task.Network.Matryoshka |
| r32 | Task.Network.StudentModel |
| r321 | Task.Network.StudentModel |
| r321_T08 | Task.Network.AreaOfATriangle |
| r321_T10 | Task.Network.Matryoshka |
| r322 | Task.Network.StudentModel |
| r3221 | Task.Network.StudentModel |
| r3221_T02 | Task.Network.RectangleArea |
| r3221_T04 | Task.Network.MakingASquare |
| r3221_T05 | Task.Network.MagicTrick |
| r3221_T08 | |
| 1 (Function) | Task.Network.VPattern |
| 2 (Function) | Task.Network.AreaOfATriangle |
| r3222 | Task.Network.StudentModel |
| r3222_T08 | Task.Network.AreaOfATriangle |
| r3223 | Task.Network.StudentModel |
| r3223_T04 | Task.Network.MakingASquare |
| r3223_T05 | Task.Network.MagicTrick |
| r323 | Task.Network.StudentModel |
| r323_T02 | Task.Network.CarRental |
| r323_T03 | Task.Network.Pattern |
| r323_T06 | Task.Network.TheatreRate |
| r323_T08 | Task.Network.AreaOfATriangle |
| r324 | Task.Network.StudentModel |
| r324_T02 | Task.Network.CarRental |
| r324_T03 | Task.Network.Pattern |
| r324_T06 | Task.Network.TheatreRate |
| r324_T08 | Task.Network.AreaOfATriangle |
| range | Util.NumberRange |
| rank | Domain.LinearAlgebra.Matrix |
| ratioExprGen | Domain.Math.Numeric.Generators |
| ratioExprGenNonZero | Domain.Math.Numeric.Generators |
| ratioGen | Domain.Math.Numeric.Generators |
| rationalGenerator | Domain.Math.Numeric.Generators |
| rationalRelaxedForm | Recognize.Strategy.Views |
| rationalRules | Domain.Math.Power.Utils |
| readEvidence | Database.HumanAssessment |
| readFileCSV | Main.ParserCSV |
| readNetwork | Bayes.NetworkReader |
| reciprocal | Domain.Math.Power.Rules |
| reciprocalFrac | Domain.Math.Power.Rules |
| reciprocalInv | Domain.Math.Power.Rules |
| reciprocalPower | Domain.Math.Power.Rules |
| reciprocalVar | Domain.Math.Power.Rules |
| recognizer | Recognize.Data.MathStoryProblem |
| recognizerExercise | Recognize.Strategy.Exercises |
| recognizerStrategy | Recognize.Strategy.Strategies |
| recordN | Database.Data |
| records2table | Database.Data |
| Recovery | Recognize.Data.Attribute |
| Rectangle | Recognize.Data.Attribute |
| rectangleArea | Task.RectangleArea |
| Recursive | Recognize.Data.Approach |
| reduce | Domain.LinearAlgebra.Matrix |
| relationSolvedForm | Domain.Math.Equation.Views |
| relationsSolvedForm | Domain.Math.Equation.Views |
| relationView | Domain.Math.Power.Utils |
| relative | Domain.Math.Approximation |
| relEqualityView | Recognize.Strategy.Views |
| removeDivision | |
| 1 (Function) | Domain.Math.Polynomial.Rules |
| 2 (Function) | Domain.Math.Polynomial.Balance |
| removeTimes | Recognize.Strategy.Rules |
| renameEvidence | Bayes.Evidence |
| renameNodes | Bayes.Network |
| replace | Util.String |
| replaceLeft | Recognize.Expr.Functions |
| replaceRight | Recognize.Expr.Functions |
| replaceXByMultiplication | Recognize.Data.StringLexerOptions |
| reportDatabase | Main.Report |
| requestsTable | Database.Data |
| resetAfter | Recognize.SubExpr.SEParser |
| resetSEState | Recognize.SubExpr.SEParser |
| restoreWildcards | Util.Expr |
| restrict | Main.Diagnose |
| Result | Recognize.Model.Result |
| result | Recognize.Data.Diagnosis |
| resultIsSimplified | Recognize.Data.Diagnosis |
| resultToBool | Recognize.Model.Result |
| returnOnJustM | Util.List |
| rewriteSqrt | Recognize.Expr.Normalform |
| root2power | Domain.Math.Power.Rules |
| rootView | Domain.Math.Power.Views |
| roundDouble | Recognize.Expr.Normalform |
| RoundingError | Recognize.Data.Attribute |
| roundNumber | Recognize.Expr.Functions |
| Row | |
| 1 (Type/Class) | Domain.LinearAlgebra.Matrix |
| 2 (Type/Class) | Main.ParserCSV |
| 3 (Data Constructor) | Recognize.Data.StringLexer |
| row | Domain.LinearAlgebra.Matrix |
| rowHeaders | Util.TableData |
| rows | Domain.LinearAlgebra.Matrix |
| rowsHalf | Recognize.Data.DiagnoseResult |
| ruleAbsorpAnd | Domain.Logic.Rules |
| ruleAbsorpOr | Domain.Logic.Rules |
| ruleApproximate | Domain.Math.Polynomial.Rules |
| ruleAssocAnd | Domain.Logic.Rules |
| ruleAssocOr | Domain.Logic.Rules |
| ruleCommAnd | Domain.Logic.Rules |
| ruleCommOr | Domain.Logic.Rules |
| ruleComplAnd | Domain.Logic.Rules |
| ruleComplOr | Domain.Logic.Rules |
| ruleDefEquiv | Domain.Logic.Rules |
| ruleDefImpl | Domain.Logic.Rules |
| ruleDeMorganAnd | Domain.Logic.Rules |
| ruleDeMorganOr | Domain.Logic.Rules |
| ruleDistrAnd | Domain.Logic.Rules |
| ruleDistrOr | Domain.Logic.Rules |
| ruleDoubleNeg | Domain.Logic.Rules |
| ruleFalseAnd | Domain.Logic.Rules |
| ruleFalseOr | Domain.Logic.Rules |
| RuleId | Recognize.Data.RuleId |
| ruleIdempAnd | Domain.Logic.Rules |
| ruleIdempOr | Domain.Logic.Rules |
| ruleNormalizeMixedFraction | Domain.Math.Polynomial.Rules |
| ruleNormalizePolynomial | Domain.Math.Polynomial.Rules |
| ruleNormalizeRational | Domain.Math.Polynomial.Rules |
| ruleNotFalse | Domain.Logic.Rules |
| ruleNotTrue | Domain.Logic.Rules |
| ruleTrueAnd | Domain.Logic.Rules |
| ruleTrueOr | Domain.Logic.Rules |
| runDomainReasoner | Service.AdviseMe |
| runParser | Recognize.Parsing.Parser |
| runParserT | Recognize.Parsing.Parser |
| runService | Service.AdviseMe |
| safeHead | Util.List |
| safeLast | Util.List |
| safePeek | Recognize.Parsing.Parse |
| safeSingleton | Util.List |
| sameConFactor | Domain.Math.Polynomial.Rules |
| sameDividend | Domain.Math.Polynomial.RationalRules |
| sameDivisor | Domain.Math.Polynomial.RationalRules |
| sameFactor | Domain.Math.Polynomial.Rules |
| satisfy | Recognize.Parsing.Parse |
| satisfyEq | Recognize.Parsing.Derived |
| satisfyWith | Recognize.Parsing.Parse |
| scale | Domain.LinearAlgebra.Matrix |
| scaleRow | Domain.LinearAlgebra.Matrix |
| scaleToOne | Domain.Math.Polynomial.Balance |
| score | Database.HumanAssessment |
| selections | Util.List |
| SemEq | Domain.Math.Power.Utils |
| seParse | Recognize.SubExpr.SEParser |
| SEParser | Recognize.SubExpr.SEParser |
| sequencer | Service.Sequencer |
| sequencerService | Service.Sequencer |
| seRecognizer | Recognize.Recognizer |
| SEState | |
| 1 (Type/Class) | Recognize.SubExpr.SEParser |
| 2 (Data Constructor) | Recognize.SubExpr.SEParser |
| set | Bayes.Evidence |
| setEntries | Domain.LinearAlgebra.Matrix |
| setEntry | Domain.LinearAlgebra.Matrix |
| setId | Bayes.Evidence |
| setN | Bayes.Evidence |
| setValueOf | Recognize.Model.EvidenceBuilder |
| showMathList | Recognize.Data.Math |
| sim | Recognize.SubExpr.Symbols |
| simpleAddExponents | Domain.Math.Power.Rules |
| simpleOrder | Bayes.EliminationOrdering |
| simplerFraction | Domain.Math.Numeric.Rules |
| simplerLinearFactor | Domain.Math.Polynomial.Rules |
| simplerPolynomial | Domain.Math.Polynomial.Rules |
| simplerSquareRootMulti | Domain.Math.Polynomial.Rules |
| Simplified | Domain.Math.Simplification |
| simplified | Domain.Math.Simplification |
| Simplify | Domain.Math.Simplification |
| simplify | |
| 1 (Function) | Domain.Logic.Views |
| 2 (Function) | Domain.Math.Simplification |
| 3 (Function) | Recognize.Strategy.Applications |
| SimplifyConfig | |
| 1 (Type/Class) | Domain.Math.Simplification |
| 2 (Data Constructor) | Domain.Math.Simplification |
| simplifyConfig | Domain.Math.Simplification |
| simplifyExercise | Recognize.Strategy.Exercises |
| simplifyPower | Domain.Math.Power.Rules |
| simplifyRule | Domain.Math.Simplification |
| simplifyStep | Domain.Logic.Strategies |
| simplifyStrategy | Recognize.Strategy.Strategies |
| simplifyWith | Domain.Math.Simplification |
| simSymbol | Recognize.SubExpr.Symbols |
| simulate | Bayes.Inference |
| singleNetwork | Recognize.Data.MathStoryProblem |
| size | |
| 1 (Function) | Bayes.Factor |
| 2 (Function) | Bayes.Network |
| sizeId | Bayes.Network |
| skillID | Bayes.StudentReport |
| skillText | Bayes.StudentReport |
| skillValue | Bayes.StudentReport |
| skip | Recognize.Parsing.Derived |
| Sloppiness | Recognize.Data.Attribute |
| smallStep | Recognize.Data.Step |
| smart | Domain.Math.CleanUp |
| smartRule | Domain.Math.Power.Utils |
| Solution | |
| 1 (Type/Class) | Recognize.Data.Solution |
| 2 (Data Constructor) | Recognize.Data.Solution |
| solution | Service.Types |
| somewhereAnd | Domain.Logic.Utils |
| somewhereOr | Domain.Logic.Utils |
| sortEquation | Domain.Math.Power.Utils |
| sortExpr | Domain.Math.Power.Utils |
| sortOrList | Domain.Math.Power.Utils |
| Source | Recognize.Data.Solution |
| source | Service.Types |
| specialDeMorganNot | Domain.Logic.Strategies |
| specialDistrNot | Domain.Logic.Strategies |
| specialGroupLiterals | Domain.Logic.Strategies |
| split | |
| 1 (Function) | Domain.Math.Power.Utils |
| 2 (Function) | Util.String |
| splitOn | Util.String |
| splitOn' | Util.String |
| splits | Task.MagicTrick.Recognizer |
| SqlRecord | Database.Data |
| SqlTable | |
| 1 (Type/Class) | Database.Data |
| 2 (Data Constructor) | Database.Data |
| Square | Recognize.Data.Attribute |
| squareBothSides | Domain.Math.Polynomial.Rules |
| squared | Recognize.Parsing.Interpretation |
| squareRootView | Domain.Math.SquareRoot.Views |
| squareRootViewWith | Domain.Math.SquareRoot.Views |
| state2label | Bayes.Network |
| states | Bayes.Network |
| staticOrder | Bayes.EliminationOrdering |
| Step | |
| 1 (Type/Class) | Recognize.Data.Step, Recognize.Data.Diagnosis |
| 2 (Data Constructor) | Recognize.Data.Step |
| stepBuilder | Task.Matryoshka.Assess |
| steps | Recognize.Data.Diagnosis |
| stepsA1Builder | |
| 1 (Function) | Task.VPattern.Assess |
| 2 (Function) | Task.MagicTrick.Assess |
| stepsA2Builder | |
| 1 (Function) | Task.VPattern.Assess |
| 2 (Function) | Task.MagicTrick.Assess |
| stepsA3Builder | Task.VPattern.Assess |
| stepsA4Builder | Task.VPattern.Assess |
| stepsABuilder | Task.TheatreRate.Assess |
| stepsAG1Builder | Task.Pattern.Assess |
| stepsAG2Builder | Task.Pattern.Assess |
| stepsAGBuilder | |
| 1 (Function) | Task.Pattern.Assess |
| 2 (Function) | Task.Matryoshka.Assess |
| stepsN1Builder | |
| 1 (Function) | Task.Pattern.Assess |
| 2 (Function) | Task.Matryoshka.Assess |
| 3 (Function) | Task.MagicTrick.Assess |
| stepsN2Builder | |
| 1 (Function) | Task.Pattern.Assess |
| 2 (Function) | Task.Matryoshka.Assess |
| 3 (Function) | Task.MagicTrick.Assess |
| stepsNBuilder | Task.TheatreRate.Assess |
| stepsToHTML | Recognize.Data.Step |
| stepToHTML | Recognize.Data.Step |
| stop | Recognize.SubExpr.Symbols |
| stopSymbol | Recognize.SubExpr.Symbols |
| storeEvidenceMaybe | Recognize.Model.EvidenceBuilder |
| strictPowerView | Domain.Math.Power.Views |
| strictRootView | Domain.Math.Power.Views |
| stringLexer | Recognize.Data.StringLexer |
| StringLexerOptions | Recognize.Data.StringLexerOptions |
| stringLexerOptions | Recognize.Data.StringLexerOptions |
| stringLexerOutput | Recognize.Data.StringLexer |
| stringNode | Recognize.Model.Assess |
| strToLower | Util.String |
| strToUpper | Util.String |
| StudentID | Database.Data |
| studentID | Bayes.StudentReport |
| StudentModel | Database.Data |
| studentRecords | Database.Data |
| StudentReport | |
| 1 (Type/Class) | Bayes.StudentReport |
| 2 (Data Constructor) | Bayes.StudentReport |
| studentsTable | Database.Data |
| Sub | Recognize.Data.Op |
| sub | Recognize.SubExpr.Symbols |
| sub4C | Task.MagicTrick.Assess |
| subExponents | Domain.Math.Power.Rules |
| subExprsCombs | Recognize.SubExpr.Functions |
| subMatched | Recognize.SubExpr.Functions |
| subskills | Bayes.StudentReport |
| substBackVar | Domain.Math.Polynomial.Rules |
| substitute | |
| 1 (Function) | Util.Expr |
| 2 (Function) | Recognize.Data.Op |
| substituteAllIf | Recognize.SubExpr.Functions |
| substOp | Recognize.Data.Op |
| subSymbol | Recognize.SubExpr.Symbols |
| subtract | Domain.Math.Data.MultivariatePolynomial |
| subXC | Task.MagicTrick.Assess |
| succeed | Recognize.Parsing.Derived |
| succeedIf | Recognize.Parsing.Derived |
| Success | Recognize.Model.Result |
| success | Recognize.Model.Connectives |
| Sum | Domain.Math.Data.MultivariatePolynomial |
| sum' | Recognize.Parsing.Interpretation |
| sum'' | Recognize.Parsing.Interpretation |
| summarise | Database.HumanAssessment |
| summariseTasks | Database.HumanAssessment |
| sumout | Bayes.Factor |
| sumouts | Bayes.Factor |
| sumView | Recognize.Strategy.Views |
| swap | Domain.Math.Power.Utils |
| switchRows | Domain.LinearAlgebra.Matrix |
| Table | |
| 1 (Type/Class) | Util.Table |
| 2 (Type/Class) | Util.TableData |
| 3 (Data Constructor) | Util.TableData |
| tableExists | Database.Data |
| tableList | Util.Table |
| tableName | Database.Data |
| Tables | Util.Table |
| tables | Util.Table |
| takeRoot | Domain.Math.Power.Utils |
| Tally | |
| 1 (Type/Class) | Database.HumanAssessment |
| 2 (Data Constructor) | Database.HumanAssessment |
| tally | Database.HumanAssessment |
| tally' | Database.HumanAssessment |
| Task | |
| 1 (Type/Class) | Recognize.Data.MathStoryProblem |
| 2 (Data Constructor) | Recognize.Data.MathStoryProblem |
| task | Task.MagicTrick.Recognizer |
| taskConcepts | Bayes.Script |
| taskExpand | Task.MagicTrick.Recognizer |
| taskForget | Task.MagicTrick.Recognizer |
| TaskID | Database.Data |
| taskIfZero | Task.MagicTrick.Recognizer |
| taskNetwork | Main.Tasks |
| taskRecords | Database.Data |
| tasks | Main.Tasks |
| tasksDone | Database.Data |
| tAttr | Service.Types |
| td | Util.W3CSSHTML |
| tDiagnosis | Service.Types |
| termRef | Domain.Math.Polynomial.BalanceUtils |
| testLCM | Domain.Math.Polynomial.LeastCommonMultiple |
| tGroupId | Service.Types |
| th | Util.W3CSSHTML |
| theatreRate | Task.TheatreRate.Recognizer |
| timed | Main.Diagnose |
| Timeout | Recognize.Data.DiagnoseError |
| Times | Recognize.Data.RuleId |
| times | Domain.Math.Data.MultivariatePolynomial |
| times2 | Domain.Math.Data.MultivariatePolynomial |
| times3 | Domain.Math.Data.MultivariatePolynomial |
| timesF | Domain.Math.Data.MultivariatePolynomial |
| timesNegateLeft | Domain.Math.Numeric.Rules |
| timesNegateRight | Domain.Math.Numeric.Rules |
| timesRule | Domain.Math.Equation.BalanceRules |
| tInput | Service.Types |
| tInputId | Service.Types |
| tLanguage | Service.Types |
| ToAttribute | Recognize.Strategy.Derivation |
| toDefinition | Recognize.Data.Definition |
| toDouble | Bayes.Probability |
| toEvidence | Bayes.Inference |
| toMaybe | Domain.Math.Power.Utils |
| toMultivariatePolynomial | Domain.Math.Data.MultivariatePolynomial |
| toNetwork | Bayes.Inference |
| toReport | Bayes.StudentReport |
| toStep | Recognize.Parsing.Interpretation |
| toTable | Util.TableData |
| toTableFromCols | Util.TableData |
| toTableFromRows | Util.TableData |
| tr | Util.W3CSSHTML |
| Translation | |
| 1 (Type/Class) | Bayes.StudentReport |
| 2 (Data Constructor) | Bayes.StudentReport |
| translationDescription | Bayes.StudentReport |
| translationExample | Bayes.StudentReport |
| translationLabel | Bayes.StudentReport |
| Triangle | Recognize.Data.Attribute |
| trim | |
| 1 (Function) | Recognize.Parsing.MathLexer |
| 2 (Function) | Util.String |
| trimFor | Bayes.Inference |
| trinomialPolyView | Domain.Math.Polynomial.Views |
| tSolution | Service.Types |
| tSource | Service.Types |
| tStudentReport | Service.Types |
| tStudentReports | Service.Types |
| turnIntoFraction | Domain.Math.Polynomial.RationalRules |
| tUserId | Service.Types |
| tUserIdTag | Service.Types |
| tUserRequest | Service.Types |
| twoNonAdjacentHoles | Domain.Math.Power.Utils |
| unchain | Recognize.Expr.Functions |
| unchainAll | Recognize.Expr.Functions |
| underSubst | Recognize.SubExpr.Functions |
| UnequalRelations | Recognize.Data.Attribute |
| unescape | Util.XML |
| unescapeAttr | Util.XML |
| unitPowerView | Domain.Math.Power.Views |
| unitPowerViewVar | Domain.Math.Power.Views |
| Unknown | |
| 1 (Data Constructor) | Recognize.Data.DiagnoseError |
| 2 (Data Constructor) | Recognize.Model.Result |
| unknown | Recognize.Model.Connectives |
| unsafeDivide | Domain.Math.Data.MultivariatePolynomial |
| updateVar | Recognize.Model.EvidenceBuilder |
| useColumns | Recognize.Parsing.MathLexer |
| usedVariables | Recognize.SubExpr.SEParser |
| UserId | Recognize.Data.Solution |
| userId | Recognize.Data.Solution |
| UserRequest | |
| 1 (Type/Class) | Service.Types |
| 2 (Data Constructor) | Service.Types |
| values | Bayes.Factor |
| Var | Domain.Math.Data.MultivariatePolynomial |
| var | |
| 1 (Function) | Recognize.SubExpr.Symbols |
| 2 (Function) | Domain.Math.Data.MultivariatePolynomial |
| varF | Domain.Math.Data.MultivariatePolynomial |
| variableWhitelist | Recognize.Data.StringLexerOptions |
| varLeft | Domain.Math.Polynomial.Balance |
| varLeftMinus | Domain.Math.Polynomial.Balance |
| varLeftPlus | Domain.Math.Polynomial.Balance |
| varRightMinus | Domain.Math.Polynomial.Balance |
| varRightPlus | Domain.Math.Polynomial.Balance |
| vars | |
| 1 (Function) | Bayes.Factor |
| 2 (Function) | Recognize.Expr.Functions |
| varSet | Bayes.Factor |
| varSymbol | Recognize.SubExpr.Symbols |
| varToLeft | Domain.Math.Polynomial.Rules |
| Virtual | Bayes.Evidence |
| virtual | Bayes.Evidence |
| virtualFactor | Bayes.NodeTypes |
| virtualId | Bayes.Evidence |
| Volume | Recognize.Data.Attribute |
| vPattern | Task.VPattern.Recognizer |
| w3list | Util.W3CSSHTML |
| w3panel | Recognize.Data.DiagnoseResult |
| w3right | Recognize.Data.DiagnoseResult |
| w3table | Util.W3CSSHTML |
| w3tags | Util.W3CSSHTML |
| whereDidWeGoWrong | Task.MagicTrick.Recognizer |
| wildcard | |
| 1 (Function) | Recognize.Expr.Symbols |
| 2 (Function) | Util.Expr |
| wildcardRelation | Recognize.Expr.Symbols |
| wildcardsToVars | Util.Expr |
| wildcardSymbol | Recognize.Expr.Symbols |
| withConstantFolding | Domain.Math.Simplification |
| withDistribution | Domain.Math.Simplification |
| withGuard | Util.Monad |
| within | Domain.Math.Approximation |
| withInput | Recognize.Parsing.Derived |
| withInputList | Recognize.Parsing.Parse |
| withMergeAlike | Domain.Math.Simplification |
| withModulo | Recognize.Parsing.Interpretation |
| withoutFailure | Recognize.Model.Assess |
| withSimplifySquareRoot | Domain.Math.Simplification |
| withSmartConstructors | Domain.Math.Simplification |
| wrap | Util.String |
| writeCache | Util.Cache |
| writeFileMsg | Main.Diagnose |
| writeOutput | Main.Diagnose |
| writePage | Util.W3CSSHTML |
| writeTerm | Domain.Math.Polynomial.BalanceUtils |
| writeWith | Domain.Math.Polynomial.BalanceUtils |
| zeroPower | Domain.Math.Power.Rules |
| |> | Recognize.Parsing.Parse |