একটি নির্ধারক অপ্টিমাইজেশন চ্যালেঞ্জ

13

৩০ বা ৩০ টোপলিটজ ম্যাট্রিককে বিবেচনা করুন যার সমস্ত এন্ট্রি 0 বা 1 রয়েছে এই চ্যালেঞ্জটি সবচেয়ে বড় নির্ধারক সহ ম্যাট্রিক্স সন্ধান করার জন্য একটি সহজ অপ্টিমাইজেশন চ্যালেঞ্জ।

ইনপুট কিছুই নয়

আউটপুট এ 30 বাই 30 টোপলিটজ ম্যাট্রিক্স যার সমস্ত এন্ট্রি তার নির্ধারক সহ 0 বা 1 হয়।

স্কোর আপনি আউটপুট ম্যাট্রিক্স নির্ধারক। যদি দুটি ব্যক্তি একই স্কোর পায় তবে প্রথম উত্তরটি জিতবে।

এখনও পর্যন্ত নেতৃস্থানীয় এন্ট্রি

  • 65.455.857.159.975 মধ্যে মতলব নিক মধ্যে Alger (মোটামুটিভাবে দ্বারা (10 ^ 13,8)
  • আইজ্যাক দ্বারা পাইথনে 65,455,857,159,975 (মোটামুটি 10 ​​^ 13.8)
  • 2012rcampion দ্বারা গণিতের 39,994,961,721,988 (মোটামুটি 10 ​​^ 13.6)
  • 39,788,537,400,052 ফ্লাউন্ডারিয়ার দ্বারা আর (প্রায় 10 ^ 13.6)
  • ভায়োজ- দ্বারা পাইথনে 8,363,855,075,832- (প্রায় 10 ^ 12.9)
  • মধ্যে 6.984.314.690.903 জুলিয়া অ্যালেক্স উ দ্বারা (প্রায় 10 ^ 12.8)

জুলাই 16, 2015 এ অতিরিক্ত বিরক্তি বিরক্ত করছে

এটি যদি সর্বদাই সম্ভব হয় তবে চূড়ান্ত আউটপুট নির্ধারক গণনা করতে দয়া করে স্বেচ্ছাচারিতা বা উচ্চ নির্ভুলতা পাটিগণিত ব্যবহার করুন যাতে এটি নিশ্চিত যে আমরা এটি নিশ্চিত হতে পারি (এটি সর্বদা পূর্ণসংখ্যার হওয়া উচিত)। পাইথন মধ্যে এই সহায়ক হতে হবে।

code-challenge  math  optimization 
— সম্প্রদায়
সূত্র
আমি অবাক হয়েছি যে এই সমস্যাটি ইতিমধ্যে সমাধান হয়নি। উত্তরটি সার্কুল্যান্ট ম্যাট্রিক্সের জন্য পরিচিত?
— xnor
1
@ নিকআলগার যদি গ্রন্থাগারটি সর্বসাধারণের জন্য প্রকাশ্য হয় তবে আপনি এটি ব্যবহার করতে পারেন।
— orlp
2
@ মিম্বিস দুঃখজনকভাবে তাদের মধ্যে 2 ^ 59 রয়েছে।
1
এটি আকর্ষণীয় যে দুটি স্বতন্ত্র পদ্ধতিতে সর্বাধিক সার্কুল্যান্ট ম্যাট্রিক্স নির্ধারক সহ একটি টোপলিটজ ম্যাট্রিক্স অর্জন করেছে। আমার কাছে কোনও গাণিতিক অন্তর্নিহিততা নেই কেন determin যে নির্ধারকটি বাইনারি টোপলিটজ ম্যাট্রিক্সের জন্য কেবল সাধারণ?
— lirtosiast
1
@ Min_25 আগামীকাল নাগাদ আমার সর্বোচ্চ 19 টি হওয়া উচিত। সম্পর্কিত প্রশ্নে আপনার কাছে কোড / মানগুলি পাবেন, লেম্বিক। হিউরিস্টিক অ্যালগরিদমের সাহায্যে, আমি এখন পর্যন্ত অন্যান্য দুটি পোস্টারের মতো n = 30 এর জন্য ঠিক একই মান অর্জন করেছি। একাধিকবার, সাথে জড়িত র্যান্ডমাইজেশন জড়িত। যদিও আমার অনুসন্ধানটি সার্কুল্যান্ট ম্যাট্রিক্সের মধ্যে সীমাবদ্ধ নয়, ততবার যখন আমি সর্বোচ্চে পৌঁছে যাই ফলাফল হিসাবে সার্কুল্যান্ট ম্যাট্রিক্স সহ বিটিডাব্লু, অন্য এক বিস্ময়কর ঘটনা (আমার কাছে) সত্য: n = 15 এর জন্য সর্বাধিক হ'ল 2 ^ 17।
— রেটো কোরাাদি

উত্তর:

11

মতলব, 65,455,857,159,975 (10 ^ 13.8159)

পদ্ধতিটি বেশিরভাগ এলোমেলো প্রাথমিক অনুমান সহ কিউবের অভ্যন্তরে [0,1] ^ 59 ধীরে ধীরে cent র্ধ্বমুখী এবং সমস্ত কিছু শূন্য এবং একসাথে তৈরি করার জন্য শেষে বৃত্তাকার হয়।

ম্যাট্রিক্স:

0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0
0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1
1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1
1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1
1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0
0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1
1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1
1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1
1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0
0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1
1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0
0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0
0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0
0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1
1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0   0
0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1   0
0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0   1
1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1   0
0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1   1
1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0   1
1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1   0
0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0   1
1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0   0
0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0   0
0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0   0
0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1   0
0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1   1
1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1   1
1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0   1
1   1   1   0   0   0   0   1   0   1   1   0   1   0   0   1   0   0   0   1   0   1   1   1   0   1   1   1   0   0

কোড:

% Toeplitz 0-1 determinant optimization

n = 30;
m = n + n-1;

toeplitz_map = @(w) toeplitz(w(n:-1:1), w(n:end));

objective = @(w) det(toeplitz_map(w));

detgrad = @(A) det(A)*inv(A)';

toeplitz_map_matrix = zeros(n^2,m);
for k=1:m
    ek = zeros(m,1);
    ek(k) = 1;
    M = toeplitz_map(ek);
    toeplitz_map_matrix(:,k) = M(:);
end

gradient = @(w) (reshape(detgrad(toeplitz_map(w)),1,n^2)*...
                 toeplitz_map_matrix)';

%check gradient with finite differences
w = randn(m,1);
dw = randn(m,1);
s = 1e-6;
g_diff = (objective(w+s*dw) - objective(w))/s;
g = gradient(w)'*dw;
grad_err = (g - g_diff)/g_diff

warning('off')
disp('multiple gradient ascent:')
w_best = zeros(m,1);
f_best = 0;
for trial=1:100000
    w0 = rand(m,1);
    w = w0;
    alpha0 = 1e-5; %step size
    for k=1:20
        f = objective(w);
        g = gradient(w);
        alpha = alpha0;
        for hh=1:100
            w2 = w + alpha*g;
            f2 = objective(w2);
            if f2 > f
                w = w2;
                break;
            else
                alpha = alpha/2;
            end
        end

        buffer = 1e-4;
        for jj=1:m
            if (w(jj) > 1)
                w(jj) = 1 - buffer;
            elseif (w(jj) < 0)
                w(jj) = 0 + buffer;
            end
        end
    end

    w = round(w);
    f = objective(w);
    if f > f_best
        w_best = w;
        f_best = f;
    end
    disp(trial)
    disp(f_best)
    disp(f)
end

M = toeplitz_map(w_best);

গ্রেডিয়েন্ট গণনার পিছনে গণিত:

মৌলিক দিকের অভ্যন্তরীণ পণ্যগুলিতে (অর্থাত্, হিলবার্ট-শ্মিট অভ্যন্তরীণ পণ্য), নির্ধারকের গ্রেডিয়েন্টের সাথে রিয়েজ প্রতিনিধি জি প্রদত্ত

জি = ডিট (এ) এ ^ (- *)।

মানচিত্র, জে, অপ্টিমাইজেশন ভেরিয়েবলগুলি (তির্যক মানগুলি) থেকে টপলিটজ ম্যাট্রিক্স পর্যন্ত লিনিয়ার, সুতরাং সামগ্রিক গ্রেডিয়েন্ট জি এই দুটি লিনিয়ার মানচিত্রের রচনা,

g = (ভিসি (জি) * জে) ',

যেখানে ভেক () হ'ল ভেক্টরাইজেশন অপারেটর যা একটি ম্যাট্রিক্স নেয় এবং এটি একটি ভেক্টরের মধ্যে প্রকাশ করে।

অভ্যন্তর গ্রেডিয়েন্ট আরোহ:

এর পরে আপনাকে যা করতে হবে তা হল ডায়ালগোনাল মানগুলির প্রাথমিক ভেক্টর বাছাই এবং কিছু ছোট পদক্ষেপের আকারের জন্য আলফা পুনরাবৃত্তি:

  1. w_propised = w_k + আলফা * জি_ কে

  2. ডাব্লু_ (কে + ১) পেতে, ডাব্লু_পোজ করা এবং [0,1] এর বাইরে 0 বা 1 এর মান কেটে নিন

  3. সন্তুষ্ট হওয়া পর্যন্ত পুনরাবৃত্তি করুন, তারপরে সবকিছুকে 0 বা 1 এ গোল করুন।

অভিন্ন এলোমেলো প্রাথমিক অনুমানের সাথে প্রায় 80,000 ট্রায়াল করার পরে আমার ফলাফলটি এই নির্ধারকটি অর্জন করেছিল।

— নিক অ্যালজার
সূত্র
আপনার দেওয়া ওইআইএস লিঙ্কটি সার্কুল্যান্ট ম্যাট্রিক্সের জন্য ছিল, এটি টপলিটজ ম্যাট্রিকের একটি বিশেষ ক্ষেত্রে। সুতরাং আরও ভাল এখনও সম্ভব।
— isaacg
@ আইসাক এবং খুব সম্ভবত!
হ্যাঁ অবশ্যই, আমি সে সম্পর্কে ভুল ছিলাম। আমি আমার পোস্ট এটিকে ঠিক করার জন্য সম্পাদনা করেছি।
— নিক অ্যালজার
1
হ্যাঁ, এটি পুনরুক্তি 250 এ যে মূল্য পেয়েছে এবং সেখানে 100000 পুনরাবৃত্তি রয়েছে stayed 2994003 নির্ধারকের সাথে 18x18 টোপলিটজ ম্যাট্রিক্স সংজ্ঞায়িত ভেক্টরটি ছিল [0,0,0,1,0,1,1,1,1,0,1,1,0,0,0,1,0,1,0, 0,0,1,0,1,1,1,1,0,1,1,0,0,0,1,0], যেখানে অর্ডার নীচে বাম থেকে উপরের ডানদিকে যায়।
— নিক অ্যালজার
2
আপনি একটি নতুন ধারণা নিয়ে আসার সাথে সাথে আমি আইআইআরসি সর্বাধিক প্রথম নম্বর নিয়ে আসার সাথে সাথে আমি আপনাকে জিতিয়েছিলাম। ওহ এবং এটি দেখায় যে আপনার উত্তরটি কেন গণিত করে .stackexchange.com/questions/1364471/… ।
11

নম্পির সাথে পাইথন 2, 65,455,857,159,975 ~ = 10 ^ 13.8

এটি পাহাড়ী আরোহণ, যতটা সহজ সোজা। একটি সুনির্দিষ্ট ফলাফলকে সুনিশ্চিত করতে সিমপাই ব্যবহার করে চূড়ান্ত নির্ধারক গণনা সম্পাদন করা হয়। এই নির্ধারকটির সাথে পাওয়া সমস্ত ম্যাট্রিকগুলি বিজ্ঞপ্তিযুক্ত।

এই নির্ধারকের সাথে ম্যাট্রিকগুলি পাওয়া গেছে, নীচের বাম থেকে উপরের ডানদিকে তির্যকের মান হিসাবে দেওয়া হয়েছে:

01000100101101000011100111011101000100101101000011100111011
01011101110011100001011010010001011101110011100001011010010
01100001000111011101001110100101100001000111011101001110100
01110100111010010110000100011101110100111010010110000100011
01011101110001000011010010111001011101110001000011010010111
01000101100010110100111101110001000101100010110100111101110
01000100101101000011100111011101000100101101000011100111011

প্রথমটি, ম্যাট্রিক্স হিসাবে:

[[1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1]
 [1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1]
 [1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0]
 [0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1]
 [1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1]
 [1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1]
 [1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0]
 [0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0]
 [0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1]
 [1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1]
 [1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1]
 [1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0]
 [0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0]
 [0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0]
 [0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1 0]
 [0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0 1]
 [1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1 0]
 [0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1 1]
 [1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0 1]
 [1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1 0]
 [0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 1]
 [1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0]
 [0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0]
 [0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1]
 [1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0]
 [0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0]
 [0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 0]
 [0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1]
 [1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1 0]
 [0 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 0 1 1 1]]

কোড:

import numpy as np
import sympy as sp
import random
import time
SIZE = 30

random.seed(0)

def gen_diag():
    return [random.randint(0, 1) for i in range(SIZE*2 - 1)]

def diag_to_mat(diag):
    return [diag[a:a+SIZE] for a in range(SIZE-1, -1, -1)]

def diag_to_det(diag):
    matrix = diag_to_mat(diag)
    return np.linalg.det(matrix)

def improve(diag):
    old_diag = diag
    really_old_diag = []
    while really_old_diag != old_diag:
        really_old_diag = old_diag
        for flip_at in range(SIZE * 2 - 1):
            new_diag = old_diag[:]
            new_diag[flip_at] ^= 1
            old_diag = max(old_diag, new_diag, key=diag_to_det)
    return old_diag

overall_best_score = 0
time.clock()
while time.clock() < 500:
    best = improve(gen_diag())
    best_score = diag_to_det(best)
    if best_score > overall_best_score:
        overall_best_score = best_score
        overall_best = best
        print(time.clock(), sp.Matrix(diag_to_mat(overall_best)).det(), ''.join(map(str,overall_best)))


mat = diag_to_mat(overall_best)

sym_mat = sp.Matrix(mat)

print(overall_best)
print(sym_mat.det())
— isaacg
সূত্র
1
এটি বাদাম চমৎকার কাজ.
— অ্যালেক্স এ
.227 একটু উদ্বেগজনক। আপনি কি মনে করেন যে আত্মবিশ্বাসী হওয়ার কোনও উপায় আছে যা নির্ধারক আসলে কী?
দেখে মনে হচ্ছে যে স্ট্যাকওভারফ্লো.com/ জিজ্ঞাসা / 68776363/// ২ চূড়ান্ত নির্ধারককে মূল্যায়ন করতে সহায়তা করতে পারে?
@ লেলেবিক ধন্যবাদ - সিমপাই কৌশলটি করেছেন।
— ই
সত্যিই দুর্দান্ত!
10

আর, 39 788 537 400 052

এখানে জেনেটিক অ্যালগরিদম করার চেষ্টা করছি তবে কেবল অযৌন প্রজননই। আমি আশা করি আমি চ্যালেঞ্জটি সঠিকভাবে বুঝতে পেরেছি। সম্পাদনা করুন: এটিকে কিছুটা বাড়িয়ে দিয়েছেন, একটি ভিন্ন এলোমেলো বীজ চেষ্টা করেছেন এবং 100 প্রজন্মের মধ্যে সীমাবদ্ধ।

    options(scipen=999)

toeplitz <- function(x){
# make toeplitz matrix with first row
# x[1:a] and first col x[(a+1):n]
# where n is the length of x and a= n/2
# Requires x to have even length
#
# [1,1] entry is x[a+1]

N <- length(x)/2
out <- matrix(0, N, N)
out[1,] <- x[1:N]
out[,1] <- x[(N+1):length(x)]
for (i in 2:N){
  for (j in 2:N){
    out[i,j] <- out[i-1, j-1]
  }
} 

out
}

set.seed(1002)

generations <- 100
popsize <- 25
cols <- 60
population <- matrix(sample(0:1, cols*popsize, replace=T), nc=cols)
numfresh <- 5 # number of totally random choices added to population

for (i in 1:generations){

fitness <- apply(population, 1, function(x) det(toeplitz(x)) )
mother <- which(fitness==max(fitness))[1]

population <- matrix(rep(population[mother,], popsize), nc=cols, byrow=T)
for (i in 2:(popsize-numfresh)){
  x <- sample(cols, 1)
  population[i,x] <- 1-population[i,x]
}
for (i in (popsize-numfresh +1):popsize){
  population[i,] <- sample(0:1, cols, replace=T)
}


print(population[1,])
print(fitness[mother])
print(det(toeplitz(population[1,]))) # to check correct

}

আউটপুট:

print(population[1, 1:(cols/2)]) # first row
print(population[1, (cols/2+1):(cols)]) # first column (overwrites 1st row)

to <- toeplitz(population[1,])

for (i in 1:(cols/2)) cat(to[i,], "\n")

1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 
0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 
1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 
0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 
0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 
0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 
1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 
1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 
1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 
1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 
0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 
1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 
1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 
1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 
0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 
0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 0 
0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 0 
0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 1 
1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 
0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 
0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 
1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 0 
0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 
0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 
0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 
0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 
1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 
0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 
1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1 1 
1 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 1 0 1
— Flounderer
সূত্র
ইহা খুব সুন্দর. আপনি বর্তমানে অনেক দূর দিয়ে জিতে যাচ্ছেন।
আর কোনও নয় :)
3

জুলিয়া, 6,984,314,690,902.998

এটি কেবলমাত্র 10,000,000 এলোমেলো টোপলিটজ ম্যাট্রিক তৈরি করে এবং তাদের নির্ধারকদের সর্বাধিক সম্মুখীন হওয়া রেকর্ড করে। আশা করি কেউ চমত্কার বিশ্লেষণাত্মক সমাধান নিয়ে আসবেন তবে এর মধ্যে ...

function toeplitz(a, b)
    n = length(a)
    T = Array(Int, n, n)
    T[1,:] = b
    T[:,1] = a
    for i = 2:n
        T[i,2:n] = T[i-1,1:n-1]
    end
    T
end

d = 0
A = Any[]

for i = 1:1000000
    # Construct two random 0,1 arrays
    r1 = rand(0:1, 30)
    r2 = rand(0:1, 30)

    # Compute the determinant of a toeplitz matrix constructed
    # from the two random arrays
    D = det(toeplitz(r1, r2))

    # If the computed determinant is larger than anything we've
    # encountered so far, add it to A so we can access it later
    D > d && begin
        push!(A, (D, r1, r2))
        d = D
    end
end

M,N = findmax([i[1] for i in A])

println("Maximum determinant: ", M, "\n")
println(toeplitz(A[N][2], A[N][3]))

আপনি এখানে আউটপুট দেখতে পারেন ।

— অ্যালেক্স এ।
সূত্র
আমি অবাক করি নির্ধারক গণনাটি কতটা নিখুঁত। আমি অনুমান করি যে অন্তর্নিহিত গণনাটি দ্বিগুণ নির্ভুলতায় করা হয়? দশমিক বিন্দুর পরে সংখ্যাগুলি .998 হওয়ায় সম্ভবত খুব ভাল সম্ভাবনা রয়েছে যে নিকটতম পূর্ণসংখ্যা এখনও সঠিক নির্ধারক। সাধারণত, কোনও সাধারণ উদ্দেশ্য নির্ধারক গণনা প্রয়োগ করার সময় আপনি ভাসমান পয়েন্ট নির্ভুলতার সমস্যাগুলি পেতে শুরু করবেন, উদাহরণস্বরূপ একটি স্ট্যান্ডার্ড এলআর পচনের উপর ভিত্তি করে, এই ম্যাট্রিকগুলিতে যখন তারা মোটামুটি বড় হয়ে যায়।
— রেটো কোরাডি
@ রিটোকোরাডি দেখে মনে হচ্ছে এটি নির্ধারক পেতে একটি এলইউ পচে যাওয়া ব্যবহার করে।
— অ্যালেক্স এ
3

গণিত, 39,994,961,721,988 (10 ^ 13.60)

একটি সাধারণ সিমুলেটেড অ্যানেলিং অপটিমাইজেশন পদ্ধতি; এখনও কোনও অপ্টিমাইজেশন বা টিউনিং নেই।

n = 30;
current = -\[Infinity];
best = -\[Infinity];
saved = ConstantArray[0, {2 n - 1}];
m := Array[a[[n + #1 - #2]] &, {n, n}];
improved = True;
iters = 1000;
pmax = 0.1;
AbsoluteTiming[
 While[improved || RandomReal[] < pmax,
   improved = False;
   a = saved;
   Do[
    Do[
      a[[i]] = 1 - a[[i]];
      With[{d = Det[m]},
       If[d > best,
          best = d;
          current = d;
          saved = a;
          improved = True;
          Break[];,
          If[d > current || RandomReal[] < pmax (1 - p/iters),
           current = d;
           Break[];,
           a[[i]] = 1 - a[[i]];
           ]
          ];
        ;
       ],
      {i, 2 n - 1}];,
    {p, iters}];
   ];
 ]
best
Log10[best // N]
a = saved;
m // MatrixForm

নমুনা আউটপুট:

{20.714876,Null}
39994961721988
13.602
(1  1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0
0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0
0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0
0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0
0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1
1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0
0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0
0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0
0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0
0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1
1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1
1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0
0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1
1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1
1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1   0
0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1   1
1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1   1
1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0   1
1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1   0
0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1   1
1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0   1
1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0   0
0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0   0
0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0   0
0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1   0
0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0   1
1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1   0
0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1   1
1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1   1
1   1   0   1   0   0   0   0   1   1   0   1   1   1   0   1   1   0   1   1   0   0   0   0   1   0   0   0   0   1

)
— 2012rcampion
সূত্র
1

পাইথন 2, 8 363 855 075 832

এটি একটি খুব বেসিক, জড়িত প্রায় অস্তিত্বযুক্ত কৌশল জড়িত আছে।

from scipy import linalg

start = 2**28
mdet  = 0
mmat  = []
count = 0
powr  = 1
while 1:
 count += 1
 v = map(int,bin(start)[2:].zfill(59))
 m = [v[29:]]
 for i in xrange(1,30):
     m += [v[29-i:59-i]]
 d = 0
 try: d = linalg.det(m, check_finite=False)
 except: print start
 if d > mdet:
     print d
     print m
     mdet = d
     mmat = m
     start += 1
     powr = 1
 else:
     start += 2**powr
     powr += 1
     if start>(2**59-1):
         start-=2**59-1
         powr = 1
 if count%10000==0: print 'Tried',count

5,580,000 ডলার চেষ্টা করার পরে এটি পাওয়া সেরা ম্যাট্রিক্স এখানে রয়েছে:

1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 1 0 1 0
1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 1 0 1
1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 1 0
0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 1
1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1
0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0
1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1
0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0
0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1 0
1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0 1
1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 0
0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0
0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0
0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0
0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0
0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0
1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1
0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1
1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1
1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0
1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1
1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1
1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1
1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0
1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1 1
1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0 1
0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 0
0 0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0
1 0 0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1
0 1 0 0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1

এখনো চলছে...

— Kade
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.