1use super::core::{MessageCategory, MessageKey, MessageTemplate, MessageType};
4use std::collections::HashMap;
5
6pub fn initialize_calculus_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
8 initialize_derivative_messages(registry);
9 initialize_integral_messages(registry);
10 initialize_limit_messages(registry);
11 initialize_summation_messages(registry);
12}
13
14fn initialize_derivative_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
16 registry.insert(
17 MessageKey::new(
18 MessageCategory::Calculus,
19 MessageType::DerivativePowerRule,
20 0,
21 ),
22 MessageTemplate::new(
23 "Power Rule",
24 "Apply power rule: d/dx(x^n) = n*x^(n-1)\nFor {expression}, we have n = {exponent}",
25 &["expression", "exponent"],
26 ),
27 );
28
29 registry.insert(
30 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativePowerRule, 1),
31 MessageTemplate::new(
32 "Power Rule Application",
33 "Using power rule on {expression}:\nd/dx({base}^{exponent}) = {exponent}*{base}^({exponent_minus_one})",
34 &["expression", "base", "exponent", "exponent_minus_one"]
35 )
36 );
37
38 registry.insert(
39 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativePowerRule, 2),
40 MessageTemplate::new(
41 "Power Rule for Negative Exponents",
42 "For negative exponents: d/dx(x^(-n)) = -n*x^(-n-1)\nApplying to {expression} with exponent {exponent}",
43 &["expression", "exponent"]
44 )
45 );
46
47 registry.insert(
48 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeChainRule, 0),
49 MessageTemplate::new(
50 "Chain Rule",
51 "Apply chain rule: d/dx(f(g(x))) = f'(g(x)) * g'(x)\nOuter function: {outer_function}\nInner function: {inner_function}",
52 &["outer_function", "inner_function"]
53 )
54 );
55
56 registry.insert(
57 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeChainRule, 1),
58 MessageTemplate::new(
59 "Chain Rule Step 1: Identify Functions",
60 "Identify composition of functions in {expression}\nOuter function f(u) = {outer_function}\nInner function u = {inner_function}",
61 &["expression", "outer_function", "inner_function"]
62 )
63 );
64
65 registry.insert(
66 MessageKey::new(
67 MessageCategory::Calculus,
68 MessageType::DerivativeChainRule,
69 2,
70 ),
71 MessageTemplate::new(
72 "Chain Rule Step 2: Differentiate Outer",
73 "Differentiate outer function with respect to inner:\nf'(u) = {outer_derivative}",
74 &["outer_derivative"],
75 ),
76 );
77
78 registry.insert(
79 MessageKey::new(
80 MessageCategory::Calculus,
81 MessageType::DerivativeChainRule,
82 3,
83 ),
84 MessageTemplate::new(
85 "Chain Rule Step 3: Differentiate Inner",
86 "Differentiate inner function:\ng'(x) = {inner_derivative}",
87 &["inner_derivative"],
88 ),
89 );
90
91 registry.insert(
92 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeChainRule, 4),
93 MessageTemplate::new(
94 "Chain Rule Step 4: Multiply",
95 "Multiply the derivatives:\nd/dx({expression}) = ({outer_derivative}) * ({inner_derivative}) = {result}",
96 &["expression", "outer_derivative", "inner_derivative", "result"]
97 )
98 );
99
100 registry.insert(
101 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeProductRule, 0),
102 MessageTemplate::new(
103 "Product Rule",
104 "Apply product rule: d/dx(u*v) = u'*v + u*v'\nFirst function: {first_function}\nSecond function: {second_function}",
105 &["first_function", "second_function"]
106 )
107 );
108
109 registry.insert(
110 MessageKey::new(
111 MessageCategory::Calculus,
112 MessageType::DerivativeProductRule,
113 1,
114 ),
115 MessageTemplate::new(
116 "Product Rule Step 1: Identify Factors",
117 "Identify the two factors in {expression}\nu = {first_function}\nv = {second_function}",
118 &["expression", "first_function", "second_function"],
119 ),
120 );
121
122 registry.insert(
123 MessageKey::new(
124 MessageCategory::Calculus,
125 MessageType::DerivativeProductRule,
126 2,
127 ),
128 MessageTemplate::new(
129 "Product Rule Step 2: Differentiate Each",
130 "Find derivatives of each factor:\nu' = {first_derivative}\nv' = {second_derivative}",
131 &["first_derivative", "second_derivative"],
132 ),
133 );
134
135 registry.insert(
136 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeProductRule, 3),
137 MessageTemplate::new(
138 "Product Rule Step 3: Apply Formula",
139 "Apply formula u'v + uv':\n({first_derivative})*({second_function}) + ({first_function})*({second_derivative}) = {result}",
140 &["first_derivative", "second_function", "first_function", "second_derivative", "result"]
141 )
142 );
143
144 registry.insert(
145 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeQuotientRule, 0),
146 MessageTemplate::new(
147 "Quotient Rule",
148 "Apply quotient rule: d/dx(u/v) = (u'*v - u*v') / v^2\nNumerator: {numerator}\nDenominator: {denominator}",
149 &["numerator", "denominator"]
150 )
151 );
152
153 registry.insert(
154 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeQuotientRule, 1),
155 MessageTemplate::new(
156 "Quotient Rule Step 1: Identify Parts",
157 "Identify numerator and denominator in {expression}\nu = {numerator}\nv = {denominator}",
158 &["expression", "numerator", "denominator"]
159 )
160 );
161
162 registry.insert(
163 MessageKey::new(
164 MessageCategory::Calculus,
165 MessageType::DerivativeQuotientRule,
166 2,
167 ),
168 MessageTemplate::new(
169 "Quotient Rule Step 2: Differentiate",
170 "Find derivatives:\nu' = {numerator_derivative}\nv' = {denominator_derivative}",
171 &["numerator_derivative", "denominator_derivative"],
172 ),
173 );
174
175 registry.insert(
176 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeQuotientRule, 3),
177 MessageTemplate::new(
178 "Quotient Rule Step 3: Apply Formula",
179 "Apply formula (u'v - uv')/v^2:\n(({numerator_derivative})*({denominator}) - ({numerator})*({denominator_derivative})) / ({denominator})^2 = {result}",
180 &["numerator_derivative", "denominator", "numerator", "denominator_derivative", "result"]
181 )
182 );
183
184 registry.insert(
185 MessageKey::new(
186 MessageCategory::Calculus,
187 MessageType::DerivativeConstant,
188 0,
189 ),
190 MessageTemplate::new(
191 "Derivative of Constant",
192 "The derivative of a constant is zero.\nd/dx({constant}) = 0",
193 &["constant"],
194 ),
195 );
196
197 registry.insert(
198 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeConstant, 1),
199 MessageTemplate::new(
200 "Constant Multiple Rule",
201 "Constant multiple rule: d/dx(c*f(x)) = c*f'(x)\nConstant: {constant}\nFunction: {function}\nDerivative: {constant}*({derivative}) = {result}",
202 &["constant", "function", "derivative", "result"]
203 )
204 );
205
206 registry.insert(
207 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeVariable, 0),
208 MessageTemplate::new(
209 "Derivative of Variable",
210 "The derivative of {variable} with respect to {variable} is 1.\nd/d{variable}({variable}) = 1",
211 &["variable"]
212 )
213 );
214
215 registry.insert(
216 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeImplicit, 0),
217 MessageTemplate::new(
218 "Implicit Differentiation",
219 "For implicit differentiation of {equation}:\nDifferentiate both sides with respect to {variable}",
220 &["equation", "variable"]
221 )
222 );
223
224 registry.insert(
225 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeImplicit, 1),
226 MessageTemplate::new(
227 "Implicit Differentiation: Apply Chain Rule",
228 "When differentiating {term} containing {dependent_variable}:\nApply chain rule and multiply by d{dependent_variable}/d{independent_variable}",
229 &["term", "dependent_variable", "independent_variable"]
230 )
231 );
232
233 registry.insert(
234 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeHigherOrder, 0),
235 MessageTemplate::new(
236 "Higher Order Derivative",
237 "Finding {order} order derivative of {expression}\nTake derivative {order} times with respect to {variable}",
238 &["order", "expression", "variable"]
239 )
240 );
241
242 registry.insert(
243 MessageKey::new(MessageCategory::Calculus, MessageType::DerivativeHigherOrder, 1),
244 MessageTemplate::new(
245 "Second Derivative",
246 "Second derivative d^2/dx^2({expression}):\nFirst find first derivative, then differentiate again\nFirst derivative: {first_derivative}\nSecond derivative: {second_derivative}",
247 &["expression", "first_derivative", "second_derivative"]
248 )
249 );
250
251 registry.insert(
252 MessageKey::new(MessageCategory::Calculus, MessageType::Introduction, 0),
253 MessageTemplate::new(
254 "Derivative Introduction",
255 "Finding derivative of {expression} with respect to {variable}\nThe derivative measures the rate of change",
256 &["expression", "variable"]
257 )
258 );
259
260 registry.insert(
261 MessageKey::new(MessageCategory::Calculus, MessageType::Strategy, 0),
262 MessageTemplate::new(
263 "Differentiation Strategy",
264 "To find d/d{variable}({expression}):\n{strategy_description}",
265 &["variable", "expression", "strategy_description"],
266 ),
267 );
268}
269
270fn initialize_integral_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
272 registry.insert(
273 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralPowerRule, 0),
274 MessageTemplate::new(
275 "Power Rule for Integration",
276 "Integral power rule: integral(x^n dx) = x^(n+1)/(n+1) + C, where n != -1\nFor {expression}, we have n = {exponent}",
277 &["expression", "exponent"]
278 )
279 );
280
281 registry.insert(
282 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralPowerRule, 1),
283 MessageTemplate::new(
284 "Apply Integration Power Rule",
285 "Integrating {expression}:\nintegral({base}^{exponent} d{variable}) = {base}^({exponent_plus_one})/({exponent_plus_one}) + C",
286 &["expression", "base", "exponent", "variable", "exponent_plus_one"]
287 )
288 );
289
290 registry.insert(
291 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralConstant, 0),
292 MessageTemplate::new(
293 "Integral of Constant",
294 "Integral of a constant: integral(c dx) = c*x + C\nFor constant {constant}: integral({constant} dx) = {constant}*x + C",
295 &["constant"]
296 )
297 );
298
299 registry.insert(
300 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralConstant, 1),
301 MessageTemplate::new(
302 "Constant Multiple Rule for Integration",
303 "Constant multiple rule: integral(c*f(x) dx) = c*integral(f(x) dx)\nFactor out constant {constant} and integrate {function}",
304 &["constant", "function"]
305 )
306 );
307
308 registry.insert(
309 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralUSubstitution, 0),
310 MessageTemplate::new(
311 "U-Substitution Method",
312 "Use u-substitution for {expression}\nLet u = {substitution}\nThen du = {du_expression} dx",
313 &["expression", "substitution", "du_expression"]
314 )
315 );
316
317 registry.insert(
318 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralUSubstitution, 1),
319 MessageTemplate::new(
320 "U-Substitution Step 1: Choose u",
321 "Choose substitution u = {substitution} for {expression}\nThis simplifies the integral structure",
322 &["substitution", "expression"]
323 )
324 );
325
326 registry.insert(
327 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralUSubstitution, 2),
328 MessageTemplate::new(
329 "U-Substitution Step 2: Find du",
330 "Differentiate u = {substitution}:\ndu = ({du_expression}) dx\nSolve for dx: dx = {dx_in_terms_of_du}",
331 &["substitution", "du_expression", "dx_in_terms_of_du"]
332 )
333 );
334
335 registry.insert(
336 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralUSubstitution, 3),
337 MessageTemplate::new(
338 "U-Substitution Step 3: Substitute",
339 "Substitute into integral:\nOriginal: integral({original_integrand} dx)\nAfter substitution: integral({new_integrand} du)",
340 &["original_integrand", "new_integrand"]
341 )
342 );
343
344 registry.insert(
345 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralUSubstitution, 4),
346 MessageTemplate::new(
347 "U-Substitution Step 4: Back-Substitute",
348 "After integrating in terms of u: {result_in_u}\nSubstitute back u = {substitution}: {final_result}",
349 &["result_in_u", "substitution", "final_result"]
350 )
351 );
352
353 registry.insert(
354 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralByParts, 0),
355 MessageTemplate::new(
356 "Integration by Parts",
357 "Use integration by parts: integral(u dv) = uv - integral(v du)\nChoose u = {u_choice}, dv = {dv_choice}",
358 &["u_choice", "dv_choice"]
359 )
360 );
361
362 registry.insert(
363 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralByParts, 1),
364 MessageTemplate::new(
365 "Integration by Parts: LIATE Rule",
366 "Use LIATE rule to choose u (prioritize: Logarithmic, Inverse trig, Algebraic, Trig, Exponential)\nFor {expression}, choose u = {u_choice}",
367 &["expression", "u_choice"]
368 )
369 );
370
371 registry.insert(
372 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralDefinite, 0),
373 MessageTemplate::new(
374 "Definite Integral Evaluation",
375 "Evaluate definite integral from {lower_bound} to {upper_bound}\nFirst find antiderivative, then apply bounds",
376 &["lower_bound", "upper_bound"]
377 )
378 );
379
380 registry.insert(
381 MessageKey::new(MessageCategory::Calculus, MessageType::IntegralDefinite, 1),
382 MessageTemplate::new(
383 "Fundamental Theorem of Calculus",
384 "By Fundamental Theorem: integral from {lower_bound} to {upper_bound} of f(x) dx = F({upper_bound}) - F({lower_bound})\nWhere F is antiderivative: {antiderivative}",
385 &["lower_bound", "upper_bound", "antiderivative"]
386 )
387 );
388}
389
390fn initialize_limit_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
392 registry.insert(
393 MessageKey::new(MessageCategory::Calculus, MessageType::LimitDirect, 0),
394 MessageTemplate::new(
395 "Direct Substitution",
396 "Evaluate limit as {variable} approaches {point} by direct substitution\nSubstitute {variable} = {point} into {expression}",
397 &["variable", "point", "expression"]
398 )
399 );
400
401 registry.insert(
402 MessageKey::new(MessageCategory::Calculus, MessageType::LimitDirect, 1),
403 MessageTemplate::new(
404 "Direct Substitution Result",
405 "Direct substitution gives:\nlim({variable} -> {point}) {expression} = {result}",
406 &["variable", "point", "expression", "result"],
407 ),
408 );
409
410 registry.insert(
411 MessageKey::new(MessageCategory::Calculus, MessageType::LimitIndeterminate, 0),
412 MessageTemplate::new(
413 "Indeterminate Form Detected",
414 "Direct substitution gives indeterminate form: {indeterminate_form}\nNeed algebraic manipulation or L'Hopital's rule",
415 &["indeterminate_form"]
416 )
417 );
418
419 registry.insert(
420 MessageKey::new(
421 MessageCategory::Calculus,
422 MessageType::LimitIndeterminate,
423 1,
424 ),
425 MessageTemplate::new(
426 "Resolve Indeterminate Form",
427 "To resolve {indeterminate_form} form:\n{resolution_strategy}",
428 &["indeterminate_form", "resolution_strategy"],
429 ),
430 );
431
432 registry.insert(
433 MessageKey::new(MessageCategory::Calculus, MessageType::LimitLHopital, 0),
434 MessageTemplate::new(
435 "L'Hopital's Rule",
436 "Apply L'Hopital's rule for {indeterminate_form} form:\nlim(f(x)/g(x)) = lim(f'(x)/g'(x))\nNumerator: {numerator}\nDenominator: {denominator}",
437 &["indeterminate_form", "numerator", "denominator"]
438 )
439 );
440
441 registry.insert(
442 MessageKey::new(MessageCategory::Calculus, MessageType::LimitLHopital, 1),
443 MessageTemplate::new(
444 "L'Hopital's Rule Application",
445 "Differentiate numerator and denominator:\nNumerator derivative: {numerator_derivative}\nDenominator derivative: {denominator_derivative}\nNew limit: lim({variable} -> {point}) ({numerator_derivative})/({denominator_derivative})",
446 &["numerator_derivative", "denominator_derivative", "variable", "point"]
447 )
448 );
449
450 registry.insert(
451 MessageKey::new(MessageCategory::Calculus, MessageType::LimitLaws, 0),
452 MessageTemplate::new(
453 "Limit Laws",
454 "Apply limit laws:\nlim(f(x) {operator} g(x)) = lim(f(x)) {operator} lim(g(x))\nEvaluate each limit separately",
455 &["operator"]
456 )
457 );
458
459 registry.insert(
460 MessageKey::new(MessageCategory::Calculus, MessageType::LimitLaws, 1),
461 MessageTemplate::new(
462 "Product Limit Law",
463 "Product law: lim(f(x)*g(x)) = lim(f(x)) * lim(g(x))\nEvaluate:\nlim(f(x)) = {first_limit}\nlim(g(x)) = {second_limit}\nProduct: {result}",
464 &["first_limit", "second_limit", "result"]
465 )
466 );
467
468 registry.insert(
469 MessageKey::new(MessageCategory::Calculus, MessageType::LimitOneSided, 0),
470 MessageTemplate::new(
471 "One-Sided Limit",
472 "Evaluate one-sided limit as {variable} approaches {point} from {direction}\nNotation: lim({variable} -> {point}{direction_symbol})",
473 &["variable", "point", "direction", "direction_symbol"]
474 )
475 );
476
477 registry.insert(
478 MessageKey::new(MessageCategory::Calculus, MessageType::LimitOneSided, 1),
479 MessageTemplate::new(
480 "Compare One-Sided Limits",
481 "Left-hand limit: lim({variable} -> {point}-) = {left_limit}\nRight-hand limit: lim({variable} -> {point}+) = {right_limit}\n{comparison_conclusion}",
482 &["variable", "point", "left_limit", "right_limit", "comparison_conclusion"]
483 )
484 );
485}
486
487fn initialize_summation_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
489 registry.insert(
490 MessageKey::new(MessageCategory::Calculus, MessageType::SummationIntroduction, 0),
491 MessageTemplate::new(
492 "Summation Introduction",
493 "We need to compute the sum Σ{variable} from {start} to {end}\nThis is a finite series with {term_count} terms",
494 &["variable", "start", "end", "term_count"]
495 )
496 );
497
498 registry.insert(
499 MessageKey::new(MessageCategory::Calculus, MessageType::SummationIntroduction, 1),
500 MessageTemplate::new(
501 "Infinite Series Introduction",
502 "Computing infinite sum Σ{expression} from {start} to ∞\nWe must first check if the series converges",
503 &["expression", "start"]
504 )
505 );
506
507 registry.insert(
508 MessageKey::new(MessageCategory::Calculus, MessageType::SummationArithmeticSeries, 0),
509 MessageTemplate::new(
510 "Arithmetic Series Detected",
511 "This is an arithmetic series with:\nFirst term a = {first_term}\nCommon difference d = {common_difference}\nNumber of terms n = {term_count}",
512 &["first_term", "common_difference", "term_count"]
513 )
514 );
515
516 registry.insert(
517 MessageKey::new(MessageCategory::Calculus, MessageType::SummationArithmeticSeries, 1),
518 MessageTemplate::new(
519 "Arithmetic Series Formula",
520 "For an arithmetic series, we use the formula:\nSum = n/2 × (2a + (n-1)d)\nWhere n is the number of terms, a is the first term, and d is the common difference",
521 &[]
522 )
523 );
524
525 registry.insert(
526 MessageKey::new(MessageCategory::Calculus, MessageType::SummationGeometricSeries, 0),
527 MessageTemplate::new(
528 "Geometric Series Detected",
529 "This is a geometric series with:\nFirst term a = {first_term}\nCommon ratio r = {common_ratio}\nNumber of terms n = {term_count}",
530 &["first_term", "common_ratio", "term_count"]
531 )
532 );
533
534 registry.insert(
535 MessageKey::new(MessageCategory::Calculus, MessageType::SummationGeometricSeries, 1),
536 MessageTemplate::new(
537 "Geometric Series Formula",
538 "For a finite geometric series when r ≠ 1:\nSum = a(1 - r^n) / (1 - r)\nFor infinite series with |r| < 1:\nSum = a / (1 - r)",
539 &[]
540 )
541 );
542
543 registry.insert(
544 MessageKey::new(MessageCategory::Calculus, MessageType::SummationGeometricSeries, 2),
545 MessageTemplate::new(
546 "Infinite Geometric Series",
547 "For an infinite geometric series with |r| < 1:\nSum = a / (1 - r)\nHere a = {first_term} and r = {common_ratio}\nSince |{common_ratio}| < 1, the series converges",
548 &["first_term", "common_ratio"]
549 )
550 );
551
552 registry.insert(
553 MessageKey::new(MessageCategory::Calculus, MessageType::SummationPowerSum, 0),
554 MessageTemplate::new(
555 "Power Sum: Sum of Constants",
556 "Sum of constants: Σ1 from 1 to n = n\nThis is the simplest case where each term is 1",
557 &[],
558 ),
559 );
560
561 registry.insert(
562 MessageKey::new(MessageCategory::Calculus, MessageType::SummationPowerSum, 1),
563 MessageTemplate::new(
564 "Power Sum: Sum of Integers",
565 "Sum of integers: Σi from 1 to n = n(n+1)/2\nThis is Gauss's famous formula for summing consecutive integers",
566 &[]
567 )
568 );
569
570 registry.insert(
571 MessageKey::new(MessageCategory::Calculus, MessageType::SummationPowerSum, 2),
572 MessageTemplate::new(
573 "Power Sum: Sum of Squares",
574 "Sum of squares: Σi² from 1 to n = n(n+1)(2n+1)/6\nThis formula sums the squares of the first n positive integers",
575 &[]
576 )
577 );
578
579 registry.insert(
580 MessageKey::new(MessageCategory::Calculus, MessageType::SummationPowerSum, 3),
581 MessageTemplate::new(
582 "Power Sum: Sum of Cubes",
583 "Sum of cubes: Σi³ from 1 to n = [n(n+1)/2]²\nRemarkably, this equals the square of the sum of integers (Nicomachus's theorem)",
584 &[]
585 )
586 );
587
588 registry.insert(
589 MessageKey::new(MessageCategory::Calculus, MessageType::SummationPowerSum, 4),
590 MessageTemplate::new(
591 "Power Sum: Higher Powers",
592 "Sum of {power}-th powers uses Faulhaber's formula\nFor higher powers, these formulas become increasingly complex polynomials in n",
593 &["power"]
594 )
595 );
596
597 registry.insert(
598 MessageKey::new(
599 MessageCategory::Calculus,
600 MessageType::SummationConvergence,
601 0,
602 ),
603 MessageTemplate::new(
604 "Convergence Test",
605 "Series converges because {reason}\nWhen a series converges, we can find its sum",
606 &["reason"],
607 ),
608 );
609
610 registry.insert(
611 MessageKey::new(
612 MessageCategory::Calculus,
613 MessageType::SummationConvergence,
614 1,
615 ),
616 MessageTemplate::new(
617 "Divergence Detected",
618 "Series diverges because {reason}\nDivergent series do not have a finite sum",
619 &["reason"],
620 ),
621 );
622
623 registry.insert(
624 MessageKey::new(MessageCategory::Calculus, MessageType::SummationFormula, 0),
625 MessageTemplate::new(
626 "Apply Formula",
627 "Substituting into {formula_name}:\n{substitution_details}",
628 &["formula_name", "substitution_details"],
629 ),
630 );
631
632 registry.insert(
633 MessageKey::new(
634 MessageCategory::Calculus,
635 MessageType::SummationSubstitution,
636 0,
637 ),
638 MessageTemplate::new(
639 "Substitute Values",
640 "Substituting n = {n_value}, a = {a_value}, {additional_params}:\n{calculation}",
641 &["n_value", "a_value", "additional_params", "calculation"],
642 ),
643 );
644
645 registry.insert(
646 MessageKey::new(MessageCategory::Calculus, MessageType::SummationResult, 0),
647 MessageTemplate::new(
648 "Final Result",
649 "The sum evaluates to: {result}\nThis is the exact value of the series",
650 &["result"],
651 ),
652 );
653
654 registry.insert(
655 MessageKey::new(MessageCategory::Calculus, MessageType::SummationResult, 1),
656 MessageTemplate::new(
657 "Simplified Result",
658 "Simplifying the sum:\n{steps}\nFinal answer: {result}",
659 &["steps", "result"],
660 ),
661 );
662}