ऐसा लगता है कि आप जिन समीकरणों से निपट रहे हैं, वे सभी संप्रदायों को साफ करने के बाद बहुपद हैं। यह एक अच्छी बात है (बीजगणितीय कार्यों को अक्सर बीजगणित से निपटने के लिए थोड़ा कठिन होता है)। हालाँकि, यह गारंटी नहीं है कि आपके समीकरणों में एक बंद-रूप समाधान है। यह एक आवश्यक बिंदु है कि बहुत से लोग वास्तव में "प्राप्त" नहीं करते हैं, भले ही वे इसे सिद्धांत रूप में जानते हों, इसलिए यह आराम करता है: बहुपद समीकरणों की काफी सरल प्रणालियां हैं जिनके लिए समाधान के संदर्भ में समाधान देने का कोई तरीका नहीं है ( th) जड़ें आदि एक प्रसिद्ध उदाहरण (एक चर में) । इस विकिपीडिया पृष्ठ को भी देखें ।nx5−x+1=0
यह कहते हुए कि, निश्चित रूप से समीकरणों की प्रणाली भी हैं जिन्हें हल किया जा सकता है, और यह जांचने के लिए सार्थक है कि क्या आपका सिस्टम उनमें से एक है। और यहां तक कि अगर आपके सिस्टम को हल नहीं किया जा सकता है, तब भी आपके सिस्टम के समीकरणों के लिए एक फॉर्म ढूंढना संभव हो सकता है जो कुछ अर्थों में सरल है। उदाहरण के लिए, केवल पहले चर वाले एक समीकरण को खोजें (भले ही इसे बीजगणितीय रूप से हल न किया जा सके), फिर एक दूसरा समीकरण जिसमें केवल पहला और दूसरा चर शामिल हैं, आदि ऐसे "सामान्य रूप" को खोजने के लिए कुछ प्रतिस्पर्धी सिद्धांत हैं। बहुपद प्रणाली; सबसे प्रसिद्ध ग्रोबर आधार सिद्धांत है, और एक प्रतिस्पर्धा नियमित श्रृंखला का सिद्धांत है।
कंप्यूटर बीजगणित प्रणाली मेपल (पूर्ण प्रकटीकरण: मैं उनके लिए काम करता हूं) में दोनों को लागू किया जाता है। solve
आदेश आम तौर पर Groebner आधार प्रणाली को बुलाती है, मुझे विश्वास है, और है कि जल्दी से अपने लैपटॉप पर एक रोकने के लिए grinds। मैंने नियमित श्रृंखला संगणना चलाने की कोशिश की और इसमें जितना धैर्य है, उससे अधिक समय लगता है, लेकिन यह बुरी तरह से स्मृति-वार नहीं लगता है। यदि आप रुचि रखते हैं, तो मेरे द्वारा उपयोग की जाने वाली कमांड के लिए सहायता पृष्ठ यहाँ है , और यहाँ वह कोड है जिसका मैंने उपयोग किया है:
restart;
sys, vars := {theta*H - rho_p*sigma_p*
Cp*(Us/N) - rho_d*sigma_d*D*(Us/N)*rho_a*sigma_a*
Ca*(Us/N) = 0,
rho_p*sigma_p*Cp*(Us/N) + rho_d*sigma_d*
D*(Us/N)*rho_a*sigma_a*Ca*(Us/N) + theta*H = 0,
(1/omega)*Ua - alpha*Up - rho_p*psi_p*
Up*(H/N) - Mu_p*sigma_p*Up*(Cp/N) -
Mu_a*sigma_a*Up*(Ca/N) - Theta_p*
Up + Nu_up*(Theta_*M + Zeta_*D) = 0,
alpha*Up - (1/omega)*Ua - rho_a*psi_a*
Ua*(H/N) - Mu_p*sigma_p*Ua*(Cp/N) -
Mu_a*sigma_a*Ua*(Ca/N) - Theta_a*
Ua + Nu_ua*(Theta_*M + Zeta_*D) = 0,
(1/omega)*Ca + Gamma_*Phi_*D + rho_p*psi_p*
Up*(H/N) + Mu_p*sigma_p*Up*(Cp/N) +
Mu_a*sigma_a*Up*(Ca/N) - alpha*Cp - Kappa_*
Cp - Theta_p*Cp + Nu_cp*(Theta_*M + Zeta_*D) = 0,
alpha*Cp + Gamma_*(1 - Phi_)*D + rho_a*psi_a*
Ua*(H/N) + Mu_p*sigma_p*Ua*(Cp/N) +
Mu_a*sigma_a*Ua*(Ca/N) - (1/omega)*
Ca - Kappa_*Tau_*Ca - Theta_a*Ca +
Nu_ca*(Theta_*M + Zeta_*D) =
0, Kappa_*Cp + Kappa_*Tau_*Ca - Gamma_*Phi_*
D - Gamma_*(1 - Phi_)*D -
Zeta_*D + Nu_d*(Theta_*M + Zeta_*D) = 0,
Us + H + Up + Ua + Cp + Ca + D = 0,
Up + Ua + Cp + Ca + D = 0}, {Us, H, Up, Ua, Cp, Ca, D, N,
M}:
sys := subs(D = DD, sys):
vars := subs(D = DD, vars):
params := indets(sys, name) minus vars:
ineqs := [theta > 0 , rho_p > 0 , sigma_p >
0 , rho_d > 0 , sigma_d > 0 ,
rho_a > 0 , sigma_a > 0 ,
omega > 0 , alpha > 0 , psi_p > 0 , Mu_p > 0 ,
Mu_a > 0 , Theta_p > 0 , Nu_up > 0 , Theta_ >
0 , Zeta_ > 0 , psi_a > 0 ,
Theta_a > 0 , Nu_ua > 0 , Gamma_ > 0 , Phi_ >
0 , Kappa_ > 0 , Nu_cp > 0 ,
Tau_ > 0 , Nu_ca > 0]:
with(RegularChains):
R := PolynomialRing([vars[], params[]]):
sys2 := map(numer, map(lhs - rhs, normal([sys[]]))):
sol := LazyRealTriangularize(sys2,[],map(rhs, ineqs),[],R);