0-1 मैट्रिक्स वेक्टर गुणन के स्वचालित अनुकूलन

22

सवाल:

क्या कोड उत्पन्न करने के लिए कोई स्थापित प्रक्रिया या सिद्धांत है जो कुशलता से मैट्रिक्स-वेक्टर गुणा को लागू करता है, जब मैट्रिक्स घने और केवल शून्य और लोगों से भरा होता है? आदर्श रूप से, अनुकूलित कोड डुप्लिकेट किए गए काम को कम करने के लिए पहले से गणना की गई जानकारी का व्यवस्थित उपयोग करेगा।

दूसरे शब्दों में, मैं एक मैट्रिक्स है $M$ और मैं कुछ पर आधारित precomputation क्या करना चाहते $M$ , कि कंप्यूटिंग कर देगा $Mv$ संभव के रूप में कुशल के रूप में जब मैं बाद में वेक्टर प्राप्त $v$ ।

$M$ एक आयताकार घने बाइनरी मैट्रिक्स है जिसे "संकलन समय" में जाना जाता है, जबकि $v$ एक अज्ञात वास्तविक वेक्टर है जो केवल "रन टाइम" में जाना जाता है।

उदाहरण 1: (खिड़की खिसकना)

अपनी बात को स्पष्ट करने के लिए एक आसान छोटे उदाहरण का उपयोग करता हूं। मैट्रिक्स पर विचार करें,

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 \end{matrix}] .

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1\\ & 1 & 1 & 1 & 1 & 1 \\ & & 1 & 1 & 1 & 1 & 1\\ & & & 1 & 1 & 1 & 1 & 1\end{bmatrix}.$ मान लीजिए कि हम

पाने केलिए इस मैट्रिक्स को वेक्टर

v

$v$ परलागू करते हैं। फिर परिणाम की प्रविष्टियां हैं,

w = M v

$w = Mv$

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} \\ w_{2} & = v_{2} + v_{3} + v_{4} + v_{5} + v_{6} \\ w_{3} & = v_{3} + v_{4} + v_{5} + v_{6} + v_{7} \\ w_{4} & = v_{4} + v_{5} + v_{6} + v_{7} + v_{8} \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5\\ w_2 &= v_2 + v_3 + v_4 + v_5 + v_6\\ w_3 &= v_3 + v_4 + v_5 + v_6 + v_7\\ w_4 &= v_4 + v_5 + v_6 + v_7 + v_8 \end{align}$

एक मानक मैट्रिक्स-वेक्टर गुणा करना इस तरह से गणना करेगा। हालांकि, इस काम का एक बहुत कुछ बेमानी है। हम "रनिंग टोटल" का ट्रैक रखते हुए कम लागत पर समान मैट्रिक्स की गणना कर सकते हैं, और अगला नंबर प्राप्त करने के लिए जोड़ / घटाना:

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} \\ w_{2} & = w_{1} + v_{6} - v_{1} \\ w_{3} & = w_{2} + v_{7} - v_{2} \\ w_{4} & = w_{3} + v_{8} - v_{3} \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5\\ w_2 &= w_1 + v_6 - v_1\\ w_3 &= w_2 + v_7 - v_2\\ w_4 &= w_3 + v_8 - v_3 \end{align}$

उदाहरण 2: (पदानुक्रमित संरचना)

पिछले उदाहरण में, हम केवल एक चालू कुल का ट्रैक रख सकते हैं। हालांकि, आमतौर पर किसी को मध्यवर्ती परिणामों के पेड़ को बनाने और संग्रहीत करने की आवश्यकता होगी। उदाहरण के लिए, कोई व्यक्तिकुशलतापूर्वक मध्यवर्ती परिणामों के पेड़ का उपयोग करकेगणना कर सकता है:

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 \\ 1 & 1 \\ 1 & 1 \\ 1 & 1 \end{matrix}]

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\ 1 & 1 & 1 & 1 \\ & & & & 1 & 1 & 1 & 1\\ 1 & 1 \\ & & & & 1 & 1 \\ & & 1 & 1 \\ & & & & & & 1 & 1\end{bmatrix}$

w = M v

$w = Mv$

और गणना करें , और उन्हें पाने के लिए जोड़ें । $w_5$ $w_7$ $w_3$
और गणना करें , और उन्हें पाने के लिए जोड़ें । $w_4$ $w_6$ $w_2$
पाने के लिए और जोड़ें $w_2$ $w_3$ $w_1$

ऊपर के उदाहरणों में संरचना को देखना आसान है, लेकिन जिन वास्तविक मैट्रिसेस में मेरी दिलचस्पी है, उनके लिए संरचना इतनी सरल नहीं है।

उदाहरण 3: (निम्न रैंक)

कुछ भ्रम को दूर करने के लिए, मैट्रिसेस आम तौर पर विरल नहीं होते हैं। विशेष रूप से, इस समस्या को हल करने के लिए एक विधि को मैट्रिसेस लागू करने के लिए कुशल तरीकों को खोजने में सक्षम होने की आवश्यकता होती है जहां बड़े ब्लॉक लोगों से भरे होते हैं। उदाहरण के लिए, विचार करें

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 \end{matrix}] .

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & & \\ 1 & 1 & 1 & 1 & & \\ 1 & 1 & 1 & 1 & & \end{bmatrix}.$

इस मैट्रिक्स को दो रैंक -1 मेट्रिस, अंतर के रूप में विघटित किया जा सकता है।

M = [\begin{matrix} 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \end{matrix}] - [\begin{matrix} 1 & 1 \\ 1 & 1 \\ 1 & 1 \end{matrix}]

$M = \begin{bmatrix}1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1\end{bmatrix} - \begin{bmatrix}& & & & & \\ & & & & & \\ & & & & 1 & 1 \\ & & & & 1 & 1 \\ & & & & 1 & 1\end{bmatrix}$

तो एक वेक्टर पर इसकी क्रिया को कुशलतापूर्वक , गणना की जा सकती है $w := Mv$

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} + v_{6} \\ w_{2} & = w_{1} \\ w_{3} & = w_{2} - v_{5} - v_{6} \\ w_{4} & = w_{3} \\ w_{5} & = w_{4} . \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5 + v_6 \\ w_2 &= w_1 \\ w_3 &= w_2 - v_5 - v_6 \\ w_4 &= w_3 \\ w_5 &= w_4. \end{align}$

प्रेरणा:

मैं कुछ छवि प्रसंस्करण के लिए एक संख्यात्मक विधि पर काम कर रहा हूं, और कई बड़े घने हैं जो विभिन्न संरचनाओं के साथ होते हैं जो सभी समय के लिए तय किए जाते हैं। बाद में इन मैट्रिक्स कई अज्ञात वैक्टर लिए लागू किया जा करने की आवश्यकता होगी उस उपयोगकर्ता के इनपुट पर निर्भर करेगा। अभी मैं पेन्सिल के आधार पर कुशल कोड के साथ आने के लिए पेंसिल-एंड-पेपर का उपयोग कर रहा हूं, लेकिन मैं सोच रहा हूं कि क्या प्रक्रिया स्वचालित हो सकती है। $0-1$ $v_i$

संपादित करें: (पोस्टस्क्रिप्ट)

अब तक के सभी उत्तर (9/5/15 के अनुसार) दिलचस्प हैं, लेकिन किसी ने भी इस सवाल का संतोषजनक जवाब नहीं दिया, जैसा कि मुझे उम्मीद थी। संभवतः यह पता चला है कि यह एक कठिन शोध प्रश्न है, और कोई भी एक अच्छा जवाब नहीं जानता है।

जब से समय समाप्त हुआ है, मैं ईविलजेस के उत्तर का इनाम दे रहा हूं क्योंकि यह सही प्रश्न है। हालाँकि, मैं चाहता हूं कि उत्तर में अधिक स्पष्ट और विस्तृत स्पष्टीकरण हो।

tranisstor का जवाब इस सवाल और ऑनलाइन बूलियन मैट्रिक्स-वेक्टर गुणन (ओएमवी) समस्या के बीच एक संबंध बनाता है, लेकिन कनेक्शन वास्तव में यह सवाल नहीं पूछ रहा है। विशेष रूप से, निम्नलिखित धारणा वास्तव में फिट नहीं है (बोल्ड जोर मेरा),

अब लगता है कि सभी के लिए $n \leq n_0$ और सभी मैट्रिक्स $n \times n$ $M$ हम एक एल्गोरिथ्म पता , वह सब वैक्टर के लिए गणना करता है सही मायने में subquadratic समय में, यानी समय में कुछ के लिए । $A_{n,M}$ $v$ $Mv$ $O(n^{2 - \varepsilon})$ $\varepsilon > 0$

सभी मेट्रिसेस के लिए सबक्वैड्रैटिक एल्गोरिदम मौजूद हैं या नहीं, एक विशिष्ट मैट्रिक्स के लिए एक एल्गोरिथ्म खोजने का सवाल है जो कि जितनी जल्दी हो सके। अधिकांश 0-1 मेट्रिक्स यादृच्छिक शोर की तरह दिखते हैं और (अगर मुझे लगता है) शायद सबक्वैड्रिक एल्गोरिदम नहीं है। हालांकि, यह तथ्य कि वास्तव में खराब मैट्रिस हैं, मुझे एक अच्छे मैट्रिक्स पर तेजी से एल्गोरिथ्म खोजने से नहीं रोकते हैं, उदाहरण के लिए, एक "स्लाइडिंग विंडो" मैट्रिक्स।

vzn के उत्तर, पहला उत्तर , दूसरा उत्तर दिलचस्प है (और मेरी राय में इतने सारे डाउनवोट के लायक नहीं हैं), लेकिन वे वहाँ टिप्पणियों में चर्चा किए गए कारणों के लिए सवाल पर लागू नहीं होते हैं।

linear-algebra matrices program-optimization

— निक अल्जर
स्रोत

1

यदि आपका मैट्रिक्स इस रूप का है, तो TDMA यह बैंड मैट्रिक्स, थॉमस एल्गोरिथ्म है। अभी तक 0-1 नहीं लेकिन इस सुविधा का फायदा उठाया जाना चाहिए।

— ईविल

@ ईवीएलजेएस मैट्रिक्स केवल विशेष उदाहरण के लिए बैंडेड होने के लिए होता है। सामान्य तौर पर यह बैंडेड नहीं होगा। मैंने एक और उदाहरण जोड़ा है जो बैंडेड नहीं है।

— निक अल्ज

आपके पास बहुत सारे निरंतर मैट्रिसेस N x M हैं जो कि बाइनरी हैं, असली वैक्टर हैं, और प्रति उदाहरण प्रीप्रोसेसिंग चरण के दौरान इष्टतम निष्पादन पथ को प्राथमिकता देना चाहते हैं? इस तरह के ऑपरेशन का आउटपुट मैट्रिक्स के प्रति हार्डकोड कोड के साथ कोड है और आप ऐसा करने के लिए विधि चाहते हैं? उदाहरण के अनुसार, मैं प्रति मैट्रिक्स का मतलब है। बस जाँच रहा हूँ।

— ईविल

@ ईवीएलजेएस यह सवाल उस स्थिति के बारे में है जहां एक ज्ञात बाइनरी मैट्रिक्स

, जिसे कई अज्ञात वास्तविक वैक्टर पर लागू किया जाएगा

M

$M$

बाद के समय में

पर। के आधार पर

केवल, हम एक कोड है कि लागू होगी precompute करना चाहते हैं

बाद में जब हम प्राप्त कुशलता से संभव के रूप में है, ताकि

, हम गणना कर सकता है

जितनी जल्दी हो सके। इस प्रश्न को प्रेरित करने वाले विशेष एप्लिकेशन में मेरे पास इस तरह के 12 (वास्तव में) बाइनरी मैट्रिसेज़ हैं जो सभी समय के लिए तय किए गए हैं, जबकि वैक्टर

अप्रत्याशित हैं और प्रोग्राम के उपयोगकर्ता से इनपुट पर निर्भर हैं।

v_{i}

$v_i$

M

$M$

M

$M$

v_{i}

$v_i$

M v_{i}

$M v_i$

v_{i}

$v_i$

— निक अल्लाफ़

1

दो तत्वों के क्षेत्र में, न्यूनतम एक्सओआर-गेट सर्किट की गणना करने की समस्या जो किसी दिए गए रैखिक परिवर्तन को अनुकरण करती है, एनपी-हार्ड है। देखें cstheory.stackexchange.com/a/32272/225

— रयान विलियम्स

5

यदि यह संभव है तो मैट्रिक्स के बैंडेड ट्रिडिओगनल प्रकृति का दोहन करने की कोशिश करें।
अन्यथा यदि मैट्रिक्स में केवल भिन्न मानों की एक निरंतर संख्या होती है (जो निश्चित रूप से द्विआधारी हो रही है), तो आपको मेलमैन एल्गोरिथ्म (एडो लिबर्टी, स्टीवन डब्ल्यू। जकर द्वारा येल विश्वविद्यालय की तकनीकी रिपोर्ट # 1402 में) आज़माना चाहिए: परिमित शब्दकोश से अनुकूलित
कॉमन सक्सेक्सप्रेशन एलिमिनेशन को कुछ समय के लिए मल्टीपल कॉन्स्टेंट गुणा के रूप में जाना जाता है, लेकिन गेट-लेवल पर नीचे जाना एक विकल्प है - यहां इस्तेमाल किए गए पैटर्न को समाधान के रूप में अलग से इस्तेमाल किया जा सकता है या अन्य तरीकों के साथ मर्ज किया जा सकता है, इसके लिए पेपर "कॉमन सब-एक्सप्रेशन एलिमिनेशन निंग वू, जिआओकियांग झांग, यूंफेई ये, और लिडॉन्ग लैन द्वारा "इंजीनियरिंग एंड कंप्यूटर साइंस 2013 विश्व की कार्यवाही की कार्यवाही में प्रकाशित" ए न्यू गेट-लेवल डिले कम्प्यूटिंग विधि "के साथ एल्गोरिथम 2013 वॉल्यूम 23 WCECEC 2013, 23-25 अक्टूबर, 2013 सैन फ्रांसिस्को, यूएसए " गेट स्तर सीएसई

वहाँ भी क्रूड लेकिन काम करने की विधि है, स्थिरांक के साथ प्रतीकात्मक मैट्रिक्स उत्पन्न करने के लिए, चर के साथ वेक्टर और इसे संकलक से स्टेटिक सिंगल असिंगमेंट (एसएसए) पर प्लग करें, जो हाथ से मैटरिस लिखने की प्रक्रिया को स्वचालित करता है।

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} \\ w_{2} & = w_{1} + v_{6} - v_{1} \\ w_{3} & = w_{2} + v_{7} - v_{2} \\ w_{4} & = w_{3} + v_{8} - v_{3} \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5 \\ w_2 &= w_1 + v_6 - v_1 \\ w_3 &= w_2 + v_7 - v_2 \\ w_4 &= w_3 + v_8 - v_3 \end{align}$

\begin{aligned} t m p_{1} & = v_{2} + v_{3} + v_{4} + v_{5} \\ w_{1} & = v_{1} + t m p_{1} \\ w_{2} & = t m p_{1} + v_{6} \\ w_{3} & = w_{2} + v_{7} - v_{2} \\ w_{4} & = w_{3} + v_{8} - v_{3} \end{aligned}

$\begin{align} tmp_1 &= v_2 + v_3 + v_4 + v_5 \\ w_1 &= v_1 + tmp_1 \\ w_2 &= tmp_1 + v_6 \\ w_3 &= w_2 + v_7 - v_2 \\ w_4 &= w_3 + v_8 - v_3 \end{align}$

\begin{aligned} w_{1} & = v_{1} + v_{2} + v_{3} + v_{4} + v_{5} + v_{6} \\ w_{2} & = w_{1} \\ w_{3} & = w_{2} - v_{5} - v_{6} \\ w_{4} & = w_{3} \\ w_{5} & = w_{4} . \end{aligned}

$\begin{align} w_1 &= v_1 + v_2 + v_3 + v_4 + v_5 + v_6 \\ w_2 &= w_1 \\ w_3 &= w_2 - v_5 - v_6 \\ w_4 &= w_3 \\ w_5 &= w_4. \end{align}$

\begin{aligned} t m p_{1} & = v_{1} + v_{2} + v_{3} + v_{4} \\ t m p_{2} & = v_{5} + v_{6} \\ w_{1} & = t m p_{1} + t m p_{2} \\ w_{2} & = w_{1} \\ w_{3} & = w_{2} - t m p_{2} \\ w_{4} & = w_{3} \\ w_{5} & = w_{4} . \end{aligned}

$\begin{align} tmp_1 &= v_1 + v_2 + v_3 + v_4 \\ tmp_2 &= v_5 + v_6 \\ w_1 &= tmp_1 + tmp_2 \\ w_2 &= w_1 \\ w_3 &= w_2 - tmp_2 \\ w_4 &= w_3 \\ w_5 &= w_4. \end{align}$

— बुराई
स्रोत

(re rev5) plz "सदाबहार विधि" पर रिफ दें। यह भी, क्या है एसएसए? CYK गतिशील एल्गोरिथ्म?

— vzn

मैंने इस उत्तर को पुरस्कृत किया है, और अपने मूल प्रश्न को संपादित करने के बारे में बताया है।

— निक अल्ज

8

यह एक खुले अनुसंधान प्रश्न से संबंधित है, जिसे "ऑनलाइन बूलियन मैट्रिक्स-वेक्टर गुणा (OMv) समस्या" के रूप में जाना जाता है। यह समस्या निम्नानुसार पढ़ती है (देखें [1]): एक बाइनरी दी $n \times n$ मैट्रिक्स $M$ तथा $n$ बाइनरी कॉलम वैक्टर $v_1, \dots, v_n$ , हमें गणना करने की आवश्यकता है $M v_i$ से पहले $v_{i+1}$ आता है।

ध्यान दें कि प्रश्न से समस्या कुछ हद तक सामान्य है: यह इसके लिए अनुमति देता है $m \times n$ मैट्रिसेस और वास्तविक मूल्य वाले वैक्टर। उस समस्या का निरीक्षण करें $n \times n$ मैट्रीस और बुलियन वैक्टर "आसान" है, क्योंकि यह एक विशेष मामला प्रस्तुत करता है।

स्पष्ट रूप से, ऑनलाइन बूलियन मैट्रिक्स-वेक्टर गुणन समस्या के लिए भोली एल्गोरिथ्म (जो सिर्फ मानक मैट्रिक्स-वेक्टर-गुणन का उपयोग करता है) में समय लगता है $O(n^3)$ । एक अनुमान है (उदाहरण के लिए देखें [1]) कि यह वास्तव में तेजी से नहीं किया जा सकता है $O(n^3)$ . (In more detail, this conjecture goes as follows: There exists no truly subcubic algorithm, which solves the Online Boolean Matrix-Vector Multiplication Problem, i.e. there is no algorithm with running time $O(n^{3 - \varepsilon})$ for $\varepsilon > 0$ ).

It is known that Williams's algorithm solves this problem in time $O(n^3 / \log^2 n)$ . See [2] for more details.

It would be a breakthrough in the area of conditional lower bounds, if one could prove or disprove the above conjecture.

[1] एक ऑनलाइन मैट्रिक्स-वेक्टर गुणन अनुमान के माध्यम से गतिशील समस्याओं के लिए कठोरता को एकजुट करना और मजबूत करना। हेनज़िंगर, क्रिनिंगर, नानौंगकाई और सारनुरक द्वारा
[ http://eprints.cs.univie.ac.at/4351/1/OMv_conjecture.pdf ]

[२] मैट्रिक्स-सदिश गुणन उप-द्विघात समय में: (कुछ पूर्वप्रक्रम आवश्यक है)। विलियम्स द्वारा
[ http://dl.acm.org/citation.cfm?id=1283383.1283490 ]

अद्यतन करें

टिप्पणियों में एक प्रश्न इस प्रकार था: हम जानते हैं $M$ संकलन के समय। क्या हम अपने एल्गोरिथ्म को सूट नहीं कर सकते $M$ , तो OMv समस्या (अनुमान) लागू नहीं होती है? हम देखेंगे कि यह मामला नहीं है, जब तक कि ओएमवी अनुमान विफल नहीं होता है।

The proof idea is simple: Assume we could give fast algorithms for all matrices up to some certain size (e.g. distinguishing all possible cases). After this certain size we use divide and conquer.

Here are the details:
Fix some $n_0 \in \mathbb{N}$ , which (without loss of generality) is a power of 2 and bigger than 2. Now assume that for all $n \leq n_0$ and all $n \times n$ matrices $M$ we know an algorithm $A_{n,M}$ , that for all vectors $v$ computes $Mv$ in truly subquadratic time, i.e. in time $O(n^{2 - \varepsilon})$ for some $\varepsilon > 0$ . (Notice that this allows an individual algorithm for each matrix up to size $n_0 \times n_0$ .)

Now we will solve OMv in truly subcubic time:
Given a binary matrix $M$ of size $n \times n$ , where $n = 2^k$ for some $k$ and $n > n_0$ , we use a divide and conquer strategy. We divide $M$ into four submatrices $M_1, M_2, M_3, M_4$ of sizes $2^{k-1} \times 2^{k-1}$ . If $2^{k-1} \leq n_0$ , then we use algorithm $A_{2^{k-1},M_i}$ , otherwise, we recurse. (As $n_0$ is some fixed number, we can pick the correct algorithm in constant time.)

Notice that we will need at most $O(\log n)$ recursion steps. Also, for $n$ vectors $v_1, \dots, v_n$ , we will $n$ computations. Thus, to process all matrix-vector multiplications we will need a total computation time of $O(n^{3 - \varepsilon} \log n)$ .

It is well known that the logarithm grows slower than any polynomial (in particular slower than any root). Fixing some $\tilde \varepsilon > 0$ with $\tilde \varepsilon < \varepsilon$ , we see that our total computation is running in truly subcubic time (in particular, in time $O(n^{3 - \tilde \varepsilon})$ ). Thus, the OMv conjecture would be wrong.

(If $M$ has size $m \times n$ and $m$ and $n$ are not powers of 2, then the bounds on the running times still apply, as we could just increase $n$ and $m$ to the next powers of 2.)

Conclusion: If you could make use of case distinctions on the input matrices to derive fast algorithms, then you could improve the OMv conjecture.

— tranisstor
स्रोत

As pointed out by author and vzn, this is not the case, vector is not binary, Matrix is not necessary N x N, and author wants to precalculate operations, and there is no need for online processing. Based on conjecture is not enough. Both papers are irrelevant to question. The case here is to precompute constant matrix to provide minimal number of operations. There will be possible different approaches for full, banded, symmetric cases.

— Evil

@EvilJS: If you allow any M x N matrix and real-valued vectors, then the problem just gets harder than the one I gave in the answer (i.e. the Online Boolean Matrix-Vector Multiplication will be a special case). If you could solve the more general problem truly faster than O(n^3), then you would also make an improvement on the conjecture (which would be big news!). Furthermore, the author says in a comment to the question that the vectors are initially unknown. If you knew all vectors beforehand, you could just use fast matrix multiplication (e.g. a version of Strassen's algorithm).

— tranisstor

I just pointed authors case "real vector". Look at Thomas matrix - only special case of matrices in O(n). I do not imply general case. And if Matrix are constant and vectors are known you hardcode answer not implement Strassen ;(

— Evil

@EvilJS: I am not sure I completely understand what you are trying to say. Of course, for special types of matrices like the Thomas matrix you can get a significant speed up, but in general this is harder. Maybe I should also point out that the problem I introduced does consider a preprocessing step (before any vector arrives). If you could tell me how to systematically "hardcode" your algorithm for any matrix that I give you, you could also improve on the conjecture (since you could implement this hardcoding step as a preprocessing step of an algorithm).

— tranisstor

agreed it works; however the 2nd ref by williams does not seem to consider binary matrices at all in particular. fyi he has slides here

— vzn

-2

this is essentially research-level CS, the problem is studied in at least two guises, one of multiplication of sparse matrices (example paper just cited), and also the special case of "binary sparse matrices" is also studied. the 2^nd case is known to be related to optimizing straight-line programs. minimal programs may also be like DAGs with two types of "gates", addition and multiplication, so some circuit minimization literature may connect with this, and possibly "off the shelf" software could be adapted for the purpose. here is a specific ref on the 2^nd case and also the same question on cstheory with some basic initial empirical study.

— vzn
स्रोत

1

I only skimmed the links, but so far I'm skeptical for two reasons. 1) The matrices are not sparse. Often the number of nonzeros is around the same as the number of zeros, yet there is often a way to come up with

O (n)

$O(n)$ algorithms for matrices with

O (n^{2})

$O(n^2)$ nonzeros, based on the patterns. 2) These papers seem to be based on only using addition and multiplication as the basic binary "gates", but in my experience it is important to also use subtraction. This would require including a subtraction binary gate, or a "multiply by -1" unary gate.

— Nick Alger

the refs are on, as the titles indicate, sparse matrices. maybe you have some different definition than those in the papers? if you are sensitive to an exact definition of sparsity (most are roughly correlated/ nearly interchangeable) it should be stated in the question.

— vzn

1

The matrices I'm interested in are dense matrices. By the way, even though I don't think this fully addresses my question, I appreciate the answer.

— Nick Alger

ok, sorry! got mixed up, didnt realize the exact question. on cursory look your example #2 has less than ½ fill & looked "sparse" to me & figured some of the sparse theory would be at least somewhat applicable. basically the more dense the matrix, the less the operation can be optimized, so probably most of the theory about this type of optimization is oriented around sparse matrices.

— vzn

-3

not sure if this problem has been studied exactly but this research is related & seems a reasonable lead/ start. it looks at hypergraph decomposition for sparse matrix multiplication. binary matrices are a special case of this approach. this approach will find more optimal strategies than the "straight" multiplication method. further optimizations (within this framework) might be possible based on the binary matrix property.

Hypergraph-Partitioning Based Decomposition for Parallel Sparse-Matrix Vector Multiplication / Umit Catalyurek and Cevdet Aykanat

— vzn
स्रोत

2

I don't see what this has to do with the question. That paper is about partitioning matrix multiplication among a distributed system, for parallel computation, to minimize the amount of inter-processor communication. What does that have to do with this question? The question does not seem to mention anything about parallel computation or inter-processor communication. I encourage you to edit your answer to make the connection more explicit.

— D.W.

afaik its the same problem and minimizing the parallel computation also minimizes a single processor implementation of the same calculations. at least, the questioner did not rule out parallel implementations.

— vzn

1

Thank you for the link. However I am skeptical of the method for this problem since it does not take advantage of the fact that the matrix entries contain only zeros and ones, whereas this property is very important, as far as I can tell. For example, the "running total" algorithm in the first example will only work if all the nonzero entries in a given column of the matrix have the same value.

— Nick Alger

NA your observation/ objection is addressed in the answer. further optimization is probably possible using the 0/1 property; this method seems to minimize total # of addition/ multiplication operations under the guise of parallelization. the addition/ multiplication operations can also be seen as "gates" in a DAG and the technique is minimizing gates. the substantial complexity of the paper reveals some of the inherent deeper/ substantial complexity of this optimization process. as stated answer is not intended to be definitive on this difficult problem, just "better than nothing".

— vzn