1use super::core::{MessageCategory, MessageKey, MessageTemplate, MessageType};
4use std::collections::HashMap;
5
6pub fn initialize_algebra_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
8 initialize_simplification_messages(registry);
9 initialize_expansion_messages(registry);
10 initialize_factorization_messages(registry);
11 initialize_rational_messages(registry);
12 initialize_polynomial_messages(registry);
13}
14
15fn initialize_simplification_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
17 registry.insert(
18 MessageKey::new(MessageCategory::Algebra, MessageType::SimplifyCombineLike, 0),
19 MessageTemplate::new(
20 "Combine Like Terms",
21 "Combine like terms in {expression}\nLike terms have the same variable parts: {like_terms}",
22 &["expression", "like_terms"]
23 )
24 );
25
26 registry.insert(
27 MessageKey::new(MessageCategory::Algebra, MessageType::SimplifyCombineLike, 1),
28 MessageTemplate::new(
29 "Combining Like Terms Step",
30 "Combine {term1} and {term2}:\n{term1} + {term2} = ({coeff1} + {coeff2})*{variable_part} = {result}",
31 &["term1", "term2", "coeff1", "coeff2", "variable_part", "result"]
32 )
33 );
34
35 registry.insert(
36 MessageKey::new(MessageCategory::Algebra, MessageType::SimplifyIdentity, 0),
37 MessageTemplate::new(
38 "Identity Element",
39 "Apply identity property: {property_description}\nSimplify {expression} to {result}",
40 &["property_description", "expression", "result"],
41 ),
42 );
43
44 registry.insert(
45 MessageKey::new(MessageCategory::Algebra, MessageType::SimplifyIdentity, 1),
46 MessageTemplate::new(
47 "Additive Identity",
48 "Additive identity: {expression} + 0 = {expression}\nThe term + 0 can be removed",
49 &["expression"],
50 ),
51 );
52
53 registry.insert(
54 MessageKey::new(MessageCategory::Algebra, MessageType::SimplifyIdentity, 2),
55 MessageTemplate::new(
56 "Multiplicative Identity",
57 "Multiplicative identity: {expression} * 1 = {expression}\nThe factor * 1 can be removed",
58 &["expression"]
59 )
60 );
61
62 registry.insert(
63 MessageKey::new(MessageCategory::Algebra, MessageType::SimplifyIdentity, 3),
64 MessageTemplate::new(
65 "Zero Property of Multiplication",
66 "Zero property: {expression} * 0 = 0\nAny expression multiplied by zero equals zero",
67 &["expression"],
68 ),
69 );
70
71 registry.insert(
72 MessageKey::new(MessageCategory::Algebra, MessageType::Step, 0),
73 MessageTemplate::new(
74 "Collect Variable Terms",
75 "Collect all terms containing {variable} on one side:\n{before} becomes {after}",
76 &["variable", "before", "after"],
77 ),
78 );
79
80 registry.insert(
81 MessageKey::new(MessageCategory::Algebra, MessageType::Step, 1),
82 MessageTemplate::new(
83 "Simplification Strategy",
84 "Strategy to simplify {expression}:\n{strategy_steps}",
85 &["expression", "strategy_steps"],
86 ),
87 );
88}
89
90fn initialize_expansion_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
92 registry.insert(
93 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandDistributive, 0),
94 MessageTemplate::new(
95 "Distributive Property",
96 "Apply distributive property: a(b + c) = ab + ac\nDistribute {factor} over {expression}",
97 &["factor", "expression"]
98 )
99 );
100
101 registry.insert(
102 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandDistributive, 1),
103 MessageTemplate::new(
104 "Distribute Factor",
105 "Distribute {factor} across ({sum_expression}):\n{factor}*({term1}) + {factor}*({term2}) = {result}",
106 &["factor", "sum_expression", "term1", "term2", "result"]
107 )
108 );
109
110 registry.insert(
111 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandFOIL, 0),
112 MessageTemplate::new(
113 "FOIL Method",
114 "Use FOIL (First, Outer, Inner, Last) to expand:\n({first_binomial})*({second_binomial})",
115 &["first_binomial", "second_binomial"]
116 )
117 );
118
119 registry.insert(
120 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandFOIL, 1),
121 MessageTemplate::new(
122 "FOIL Expansion Steps",
123 "Expanding ({a} + {b})({c} + {d}):\nFirst: {a}*{c} = {first_term}\nOuter: {a}*{d} = {outer_term}\nInner: {b}*{c} = {inner_term}\nLast: {b}*{d} = {last_term}\nSum: {result}",
124 &["a", "b", "c", "d", "first_term", "outer_term", "inner_term", "last_term", "result"]
125 )
126 );
127
128 registry.insert(
129 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandBinomial, 0),
130 MessageTemplate::new(
131 "Binomial Expansion",
132 "Expand binomial power: ({expression})^{power}\nUse binomial theorem or repeated multiplication",
133 &["expression", "power"]
134 )
135 );
136
137 registry.insert(
138 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandBinomial, 1),
139 MessageTemplate::new(
140 "Perfect Square Expansion",
141 "Perfect square: ({a} + {b})^2 = {a}^2 + 2*{a}*{b} + {b}^2\nApply to get: {result}",
142 &["a", "b", "result"],
143 ),
144 );
145
146 registry.insert(
147 MessageKey::new(MessageCategory::Algebra, MessageType::ExpandBinomial, 2),
148 MessageTemplate::new(
149 "Difference of Squares Pattern",
150 "Recognize pattern: ({a} + {b})({a} - {b}) = {a}^2 - {b}^2\nResult: {result}",
151 &["a", "b", "result"],
152 ),
153 );
154}
155
156fn initialize_factorization_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
158 registry.insert(
159 MessageKey::new(MessageCategory::Algebra, MessageType::FactorCommon, 0),
160 MessageTemplate::new(
161 "Common Factor",
162 "Factor out greatest common factor (GCF) from {expression}\nGCF = {gcf}",
163 &["expression", "gcf"],
164 ),
165 );
166
167 registry.insert(
168 MessageKey::new(MessageCategory::Algebra, MessageType::FactorCommon, 1),
169 MessageTemplate::new(
170 "Extract Common Factor",
171 "Extract {gcf} from each term:\n{expression} = {gcf}*({factored_expression})",
172 &["gcf", "expression", "factored_expression"],
173 ),
174 );
175
176 registry.insert(
177 MessageKey::new(MessageCategory::Algebra, MessageType::FactorGrouping, 0),
178 MessageTemplate::new(
179 "Factoring by Grouping",
180 "Factor by grouping for {expression}\nGroup terms: ({group1}) + ({group2})",
181 &["expression", "group1", "group2"],
182 ),
183 );
184
185 registry.insert(
186 MessageKey::new(MessageCategory::Algebra, MessageType::FactorGrouping, 1),
187 MessageTemplate::new(
188 "Grouping Method Steps",
189 "Step 1: Group {group1} has common factor {factor1}\nStep 2: Group {group2} has common factor {factor2}\nStep 3: Factor out common binomial: {result}",
190 &["group1", "factor1", "group2", "factor2", "result"]
191 )
192 );
193
194 registry.insert(
195 MessageKey::new(MessageCategory::Algebra, MessageType::FactorQuadratic, 0),
196 MessageTemplate::new(
197 "Factor Quadratic",
198 "Factor quadratic {expression}\nFind two numbers that multiply to {product} and add to {sum}",
199 &["expression", "product", "sum"]
200 )
201 );
202
203 registry.insert(
204 MessageKey::new(MessageCategory::Algebra, MessageType::FactorQuadratic, 1),
205 MessageTemplate::new(
206 "Quadratic Factoring Pattern",
207 "Factor {a}*x^2 + {b}*x + {c}\nFind factors of {a}*{c} that sum to {b}\nFactors found: {factor1} and {factor2}\nFactored form: {result}",
208 &["a", "b", "c", "factor1", "factor2", "result"]
209 )
210 );
211
212 registry.insert(
213 MessageKey::new(MessageCategory::Algebra, MessageType::FactorQuadratic, 2),
214 MessageTemplate::new(
215 "Difference of Squares Factoring",
216 "Recognize difference of squares: {a}^2 - {b}^2\nFactor as: ({a} + {b})({a} - {b})",
217 &["a", "b"],
218 ),
219 );
220}
221
222fn initialize_rational_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
224 registry.insert(
225 MessageKey::new(MessageCategory::Algebra, MessageType::RationalSimplify, 0),
226 MessageTemplate::new(
227 "Simplify Rational Expression",
228 "Simplify rational expression: {expression}\nFactor numerator and denominator, then cancel common factors",
229 &["expression"]
230 )
231 );
232
233 registry.insert(
234 MessageKey::new(MessageCategory::Algebra, MessageType::RationalSimplify, 1),
235 MessageTemplate::new(
236 "Cancel Common Factors",
237 "After factoring:\nNumerator: {numerator_factored}\nDenominator: {denominator_factored}\nCommon factor: {common_factor}\nSimplified: {result}",
238 &["numerator_factored", "denominator_factored", "common_factor", "result"]
239 )
240 );
241
242 registry.insert(
243 MessageKey::new(MessageCategory::Algebra, MessageType::RationalSimplify, 2),
244 MessageTemplate::new(
245 "Rational Expression Addition",
246 "Add rational expressions: {expr1} + {expr2}\nFind common denominator: {common_denominator}",
247 &["expr1", "expr2", "common_denominator"]
248 )
249 );
250
251 registry.insert(
252 MessageKey::new(MessageCategory::Algebra, MessageType::RationalSimplify, 3),
253 MessageTemplate::new(
254 "Rational Expression Multiplication",
255 "Multiply rational expressions: ({numerator1}/{denominator1}) * ({numerator2}/{denominator2})\nMultiply numerators and denominators:\n({numerator1}*{numerator2})/({denominator1}*{denominator2}) = {result}",
256 &["numerator1", "denominator1", "numerator2", "denominator2", "result"]
257 )
258 );
259}
260
261fn initialize_polynomial_messages(registry: &mut HashMap<MessageKey, MessageTemplate>) {
263 registry.insert(
264 MessageKey::new(
265 MessageCategory::PolynomialEquation,
266 MessageType::Introduction,
267 0,
268 ),
269 MessageTemplate::new(
270 "Polynomial Equation",
271 "Solve polynomial equation: {equation} = 0\nDegree: {degree} ({degree_name})",
272 &["equation", "degree", "degree_name"],
273 ),
274 );
275
276 registry.insert(
277 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::Strategy, 0),
278 MessageTemplate::new(
279 "Polynomial Solution Strategy",
280 "Strategy for degree {degree} polynomial:\n{strategy_description}\nWe will use the Rational Root Theorem and factorization",
281 &["degree", "strategy_description"]
282 )
283 );
284
285 registry.insert(
286 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::PolynomialRationalRoot, 0),
287 MessageTemplate::new(
288 "Rational Root Theorem",
289 "Apply Rational Root Theorem:\nPossible rational roots are p/q where:\n- p divides constant term: {constant_term}\n- q divides leading coefficient: {leading_coeff}\nCandidates: {candidates}",
290 &["constant_term", "leading_coeff", "candidates"]
291 )
292 );
293
294 registry.insert(
295 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::PolynomialRationalRoot, 1),
296 MessageTemplate::new(
297 "Test Rational Root Candidate",
298 "Test {variable} = {candidate}:\nSubstitute into {equation}:\nP({candidate}) = {evaluation} {result}",
299 &["variable", "candidate", "equation", "evaluation", "result"]
300 )
301 );
302
303 registry.insert(
304 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::PolynomialSyntheticDivision, 0),
305 MessageTemplate::new(
306 "Synthetic Division",
307 "Factor out ({variable} - {root}) using synthetic division:\nDivide {polynomial} by ({variable} - {root})",
308 &["variable", "root", "polynomial"]
309 )
310 );
311
312 registry.insert(
313 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::PolynomialSyntheticDivision, 1),
314 MessageTemplate::new(
315 "Synthetic Division Result",
316 "After dividing by ({variable} - {root}):\n{original_polynomial} = ({variable} - {root}) * ({quotient_polynomial})",
317 &["variable", "root", "original_polynomial", "quotient_polynomial"]
318 )
319 );
320
321 registry.insert(
322 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::PolynomialFactorization, 0),
323 MessageTemplate::new(
324 "Complete Factorization",
325 "Complete factorization:\n{original_polynomial} = {factored_form}\nEach factor gives a root",
326 &["original_polynomial", "factored_form"]
327 )
328 );
329
330 registry.insert(
331 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::Result, 0),
332 MessageTemplate::new(
333 "Polynomial Solutions",
334 "Solutions to {equation} = 0:\n{solutions}\nTotal: {count} roots found",
335 &["equation", "solutions", "count"],
336 ),
337 );
338
339 registry.insert(
340 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::Verification, 0),
341 MessageTemplate::new(
342 "Verify Polynomial Root",
343 "Verify {variable} = {root}:\nSubstitute into original equation:\n{verification_expression} = {result}",
344 &["variable", "root", "verification_expression", "result"]
345 )
346 );
347
348 registry.insert(
349 MessageKey::new(MessageCategory::PolynomialEquation, MessageType::Insight, 0),
350 MessageTemplate::new(
351 "Fundamental Theorem of Algebra",
352 "By the Fundamental Theorem of Algebra, a polynomial of degree {degree} has exactly {degree} roots (counting multiplicity) in the complex numbers.\nWe found {real_count} real roots",
353 &["degree", "real_count"]
354 )
355 );
356}