ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆ ಎಂದರೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಇನ್ನೊಂದನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿಶೀಲಿಸುವುದು.
ಪ್ರೋಗ್ರಾಂನಲ್ಲಿನ ಎಲ್ಲಾ ದುರ್ಬಲತೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅಥವಾ ಅವುಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಎಂದು ಸಾಬೀತುಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ವಿಧಾನಗಳಲ್ಲಿ ಇದು ಒಂದಾಗಿದೆ.
ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆಯ ಹೆಚ್ಚು ವಿವರವಾದ ವಿವರಣೆಯನ್ನು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಉದಾಹರಣೆಯಲ್ಲಿ ಕಾಣಬಹುದು ನನ್ನ ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ.
ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಸಮಸ್ಯೆಗಳ ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆಯಿಂದ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಹೋಗುತ್ತೇನೆ ಮತ್ತು ಹೇಗೆ ವಿವರಿಸುತ್ತೇನೆ
ಅವುಗಳನ್ನು ಹೇಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಔಪಚಾರಿಕ ನಿಯಮ ವ್ಯವಸ್ಥೆಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು.
ಇದನ್ನು ಮಾಡಲು, ಸಾಂಕೇತಿಕ ತತ್ವಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನನ್ನ ಸ್ವಂತ ವರ್ಚುವಲ್ ಯಂತ್ರದ ಅನಲಾಗ್ ಅನ್ನು ನಾನು ಬರೆದಿದ್ದೇನೆ.
ಇದು ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸಮೀಕರಣಗಳ ವ್ಯವಸ್ಥೆಗೆ (SMT) ಭಾಷಾಂತರಿಸುತ್ತದೆ, ಇದನ್ನು ಈಗಾಗಲೇ ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಪರಿಹರಿಸಬಹುದು.
ಸಾಂಕೇತಿಕ ಲೆಕ್ಕಾಚಾರಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಅಂತರ್ಜಾಲದಲ್ಲಿ ತುಂಡಾಗಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿರುವುದರಿಂದ,
ಅದು ಏನೆಂದು ನಾನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವಿವರಿಸುತ್ತೇನೆ.
ಸಾಂಕೇತಿಕ ಗಣನೆಯು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಡೇಟಾದಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಮತ್ತು ಇದು ಔಪಚಾರಿಕ ಪ್ರೋಗ್ರಾಂ ಪರಿಶೀಲನೆಗೆ ಮುಖ್ಯ ಸಾಧನವಾಗಿದೆ.
ಉದಾಹರಣೆಗೆ, ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಯಾವುದೇ ಧನಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದಾದ ಇನ್ಪುಟ್ ಷರತ್ತುಗಳನ್ನು ನಾವು ಹೊಂದಿಸಬಹುದು, ಎರಡನೆಯ ಋಣಾತ್ಮಕ, ಮೂರನೇ ಶೂನ್ಯ ಮತ್ತು ಔಟ್ಪುಟ್ ಆರ್ಗ್ಯುಮೆಂಟ್, ಉದಾಹರಣೆಗೆ, 42.
ಒಂದು ರನ್‌ನಲ್ಲಿನ ಸಾಂಕೇತಿಕ ಲೆಕ್ಕಾಚಾರಗಳು ನಮಗೆ ಬೇಕಾದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವೇ ಎಂಬುದಕ್ಕೆ ಉತ್ತರವನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಅಂತಹ ಇನ್ಪುಟ್ ನಿಯತಾಂಕಗಳ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೀಡುತ್ತದೆ. ಅಥವಾ ಅಂತಹ ಯಾವುದೇ ನಿಯತಾಂಕಗಳಿಲ್ಲ ಎಂಬುದಕ್ಕೆ ಪುರಾವೆ.
ಇದಲ್ಲದೆ, ನಾವು ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಪದಗಳಿಗಿಂತ ಇನ್ಪುಟ್ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು ಹೊಂದಿಸಬಹುದು ಮತ್ತು ಔಟ್ಪುಟ್ ಪದಗಳಿಗಿಂತ ಮಾತ್ರ ಆಯ್ಕೆ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ನಿರ್ವಾಹಕರ ಪಾಸ್ವರ್ಡ್.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂನ ದುರ್ಬಲತೆಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ ಅಥವಾ ನಿರ್ವಾಹಕರ ಪಾಸ್ವರ್ಡ್ ಸುರಕ್ಷಿತವಾಗಿದೆ ಎಂಬುದಕ್ಕೆ ಪುರಾವೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ.
ನಿರ್ದಿಷ್ಟ ಇನ್ಪುಟ್ ಡೇಟಾದೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂನ ಶಾಸ್ತ್ರೀಯ ಮರಣದಂಡನೆಯು ಸಾಂಕೇತಿಕ ಮರಣದಂಡನೆಯ ವಿಶೇಷ ಪ್ರಕರಣವಾಗಿದೆ ಎಂದು ಗಮನಿಸಬಹುದು.
ಆದ್ದರಿಂದ, ನನ್ನ ಅಕ್ಷರ VM ಸಹ ಪ್ರಮಾಣಿತ ವರ್ಚುವಲ್ ಯಂತ್ರದ ಎಮ್ಯುಲೇಶನ್ ಮೋಡ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು.
ಹಿಂದಿನ ಲೇಖನದ ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಅದರ ದೌರ್ಬಲ್ಯಗಳ ಚರ್ಚೆಯೊಂದಿಗೆ ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆಯ ನ್ಯಾಯಯುತ ಟೀಕೆಯನ್ನು ಕಾಣಬಹುದು.
ಮುಖ್ಯ ಸಮಸ್ಯೆಗಳೆಂದರೆ:
- ಕಾಂಬಿನೇಟೋರಿಯಲ್ ಸ್ಫೋಟ, ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆಯು ಅಂತಿಮವಾಗಿ P=NP ಗೆ ಬರುತ್ತದೆ
- ಫೈಲ್ ಸಿಸ್ಟಮ್, ನೆಟ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಇತರ ಬಾಹ್ಯ ಸಂಗ್ರಹಣೆಗೆ ಕರೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಪರಿಶೀಲಿಸಲು ಹೆಚ್ಚು ಕಷ್ಟ
- ಗ್ರಾಹಕ ಅಥವಾ ಪ್ರೋಗ್ರಾಮರ್ ಒಂದು ವಿಷಯವನ್ನು ಉದ್ದೇಶಿಸಿದಾಗ ನಿರ್ದಿಷ್ಟತೆಯಲ್ಲಿನ ದೋಷಗಳು, ಆದರೆ ತಾಂತ್ರಿಕ ವಿವರಣೆಯಲ್ಲಿ ಅದನ್ನು ಸಾಕಷ್ಟು ನಿಖರವಾಗಿ ವಿವರಿಸಲಿಲ್ಲ.
ಪರಿಣಾಮವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಆದರೆ ರಚನೆಕಾರರು ಅದರಿಂದ ನಿರೀಕ್ಷಿಸಿದ್ದಕ್ಕಿಂತ ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನವಾದದ್ದನ್ನು ಮಾಡುತ್ತದೆ.
ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಮುಖ್ಯವಾಗಿ ಆಚರಣೆಯಲ್ಲಿ ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆಯ ಬಳಕೆಯನ್ನು ಪರಿಗಣಿಸುತ್ತಿರುವುದರಿಂದ, ಸದ್ಯಕ್ಕೆ ನಾನು ಗೋಡೆಗೆ ನನ್ನ ತಲೆಯನ್ನು ಹೊಡೆಯುವುದಿಲ್ಲ ಮತ್ತು ಅಲ್ಗಾರಿದಮಿಕ್ ಸಂಕೀರ್ಣತೆ ಮತ್ತು ಬಾಹ್ಯ ಕರೆಗಳ ಸಂಖ್ಯೆಯು ಕಡಿಮೆ ಇರುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇನೆ.
ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳು ಈ ಅವಶ್ಯಕತೆಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಹೊಂದಿಕೆಯಾಗುವುದರಿಂದ, ಆಯ್ಕೆಯು ವೇವ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಿಂದ ರೈಡ್ ಒಪ್ಪಂದಗಳ ಮೇಲೆ ಬಿದ್ದಿತು: ಅವು ಟ್ಯೂರಿಂಗ್ ಪೂರ್ಣಗೊಂಡಿಲ್ಲ ಮತ್ತು ಅವುಗಳ ಗರಿಷ್ಠ ಸಂಕೀರ್ಣತೆಯು ಕೃತಕವಾಗಿ ಸೀಮಿತವಾಗಿದೆ.
ಆದರೆ ನಾವು ಅವುಗಳನ್ನು ತಾಂತ್ರಿಕ ಭಾಗದಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿ ಪರಿಗಣಿಸುತ್ತೇವೆ.
ಎಲ್ಲದರ ಜೊತೆಗೆ, ಔಪಚಾರಿಕ ಪರಿಶೀಲನೆಯು ವಿಶೇಷವಾಗಿ ಯಾವುದೇ ಒಪ್ಪಂದಗಳಿಗೆ ಬೇಡಿಕೆಯಾಗಿರುತ್ತದೆ: ಅದನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ ಒಪ್ಪಂದದ ದೋಷವನ್ನು ಸರಿಪಡಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಅಸಾಧ್ಯ.
ಮತ್ತು ಅಂತಹ ದೋಷಗಳ ಬೆಲೆ ತುಂಬಾ ಹೆಚ್ಚಿರಬಹುದು, ಏಕೆಂದರೆ ಸಾಕಷ್ಟು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಹಣವನ್ನು ಹೆಚ್ಚಾಗಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.
ನನ್ನ ಸಾಂಕೇತಿಕ ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು PHP ಮತ್ತು ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ SMT ಸೂತ್ರಗಳನ್ನು ಪರಿಹರಿಸಲು ಮೈಕ್ರೋಸಾಫ್ಟ್ ಸಂಶೋಧನೆಯಿಂದ Z3Prover ಅನ್ನು ಬಳಸುತ್ತದೆ.
ಅದರ ಮಧ್ಯಭಾಗದಲ್ಲಿ ಪ್ರಬಲವಾದ ಬಹು-ವಹಿವಾಟು ಹುಡುಕಾಟವಿದೆ, ಅದು
ಹಲವಾರು ವಹಿವಾಟುಗಳ ಅಗತ್ಯವಿದ್ದರೂ ಸಹ, ಪರಿಹಾರಗಳು ಅಥವಾ ದುರ್ಬಲತೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಸಹ , Ethereum ದುರ್ಬಲತೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ಸಾಂಕೇತಿಕ ಚೌಕಟ್ಟುಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಈ ಸಾಮರ್ಥ್ಯವನ್ನು ಕೆಲವು ತಿಂಗಳ ಹಿಂದೆ ಮಾತ್ರ ಸೇರಿಸಿದೆ.
ಆದರೆ ಈಥರ್ ಒಪ್ಪಂದಗಳು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿವೆ ಮತ್ತು ಟ್ಯೂರಿಂಗ್ ಪೂರ್ಣಗೊಂಡಿವೆ ಎಂದು ಗಮನಿಸಬೇಕಾದ ಅಂಶವಾಗಿದೆ.
PHP RIDE ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಭಾಷಾಂತರಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು Z3 SMT-ಹೊಂದಾಣಿಕೆಯ ಒಪ್ಪಂದದ ಸ್ಥಿತಿಗಳ ವ್ಯವಸ್ಥೆ ಮತ್ತು ಅವುಗಳ ಪರಿವರ್ತನೆಗಳಿಗೆ ಷರತ್ತುಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಲಾಗುತ್ತದೆ:
ಈಗ ನಾನು ಒಳಗೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸುತ್ತೇನೆ.
ಆದರೆ ಮೊದಲು, RIDE ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಭಾಷೆಯ ಬಗ್ಗೆ ಕೆಲವು ಪದಗಳು.
ಇದು ಕ್ರಿಯಾತ್ಮಕ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿ ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದ್ದು ಅದು ವಿನ್ಯಾಸದಿಂದ ಸೋಮಾರಿಯಾಗಿದೆ.
RIDE ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ ಪ್ರತ್ಯೇಕವಾಗಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರ ವ್ಯಾಲೆಟ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಲಾದ ಸಂಗ್ರಹಣೆಯಿಂದ ಮಾಹಿತಿಯನ್ನು ಹಿಂಪಡೆಯಬಹುದು ಮತ್ತು ಬರೆಯಬಹುದು.
ನೀವು ಪ್ರತಿ ವ್ಯಾಲೆಟ್‌ಗೆ ರೈಡ್ ಒಪ್ಪಂದವನ್ನು ಲಗತ್ತಿಸಬಹುದು ಮತ್ತು ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶವು ಕೇವಲ ನಿಜ ಅಥವಾ ತಪ್ಪಾಗಿರುತ್ತದೆ.
TRUE ಎಂದರೆ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ವಹಿವಾಟನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು FALSE ಎಂದರೆ ಅದು ಅದನ್ನು ನಿಷೇಧಿಸುತ್ತದೆ.
ಒಂದು ಸರಳ ಉದಾಹರಣೆ: ವ್ಯಾಲೆಟ್ ಬ್ಯಾಲೆನ್ಸ್ 100 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ ಸ್ಕ್ರಿಪ್ಟ್ ವರ್ಗಾವಣೆಯನ್ನು ನಿಷೇಧಿಸಬಹುದು.
ಉದಾಹರಣೆಯಾಗಿ, ನಾನು ಅದೇ ತೋಳ, ಮೇಕೆ ಮತ್ತು ಎಲೆಕೋಸು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇನೆ, ಆದರೆ ಈಗಾಗಲೇ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ರೂಪದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ.
ಪ್ರತಿಯೊಬ್ಬರನ್ನು ಬೇರೆ ಕಡೆಗೆ ಕಳುಹಿಸುವವರೆಗೆ ಒಪ್ಪಂದವನ್ನು ನಿಯೋಜಿಸಲಾದ ವ್ಯಾಲೆಟ್‌ನಿಂದ ಬಳಕೆದಾರರು ಹಣವನ್ನು ಹಿಂಪಡೆಯಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.
#Извлекаем положение всех объектов из блокчейна
let contract = tx.sender
let human= extract(getInteger(contract,"human"))
let wolf= extract(getInteger(contract,"wolf"))
let goat= extract(getInteger(contract,"goat"))
let cabbage= extract(getInteger(contract,"cabbage"))
#Это так называемая дата-транзакция, в которой пользователь присылает новые 4 переменные.
#Контракт разрешит её только в случае если все объекты останутся в сохранности.
match tx {
case t:DataTransaction =>
#Извлекаем будущее положение всех объектов из транзакции
let newHuman= extract(getInteger(t.data,"human"))
let newWolf= extract(getInteger(t.data,"wolf"))
let newGoat= extract(getInteger(t.data,"goat"))
let newCabbage= extract(getInteger(t.data,"cabbage"))
#0 обозначает, что объект на левом берегу, а 1 что на правом
let humanSide= human == 0 || human == 1
let wolfSide= wolf == 0 || wolf == 1
let goatSide= goat == 0 || goat == 1
let cabbageSide= cabbage == 0 || cabbage == 1
let side= humanSide && wolfSide && goatSide && cabbageSide
#Будут разрешены только те транзакции, где с козой никого нет в отсутствии фермера.
let safeAlone= newGoat != newWolf && newGoat != newCabbage
let safe= safeAlone || newGoat == newHuman
let humanTravel= human != newHuman
#Способы путешествия фермера туда и обратно, с кем-то либо в одиночку.
let t1= humanTravel && newWolf == wolf + 1 && newGoat == goat && newCabbage == cabbage
let t2= humanTravel && newWolf == wolf && newGoat == goat + 1 && newCabbage == cabbage
let t3= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage + 1
let t4= humanTravel && newWolf == wolf - 1 && newGoat == goat && newCabbage == cabbage
let t5= humanTravel && newWolf == wolf && newGoat == goat - 1 && newCabbage == cabbage
let t6= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage - 1
let t7= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage
let objectTravel = t1 || t2 || t3 || t4 || t5 || t6 || t7
#Последняя строка в разделе транзакции описывает разрешающее транзакцию условие.
#Переменные транзакции должны иметь значения 1 или 0, все объекты должны
#быть в безопасности, а фермер должен переплывать реку в одиночку
#или с кем-то на каждом шагу
side && safe && humanTravel && objectTravel
case s:TransferTransaction =>
#Транзакция вывода средств разрешена только в случае если все переплыли на другой берег
human == 1 && wolf == 1 && goat == 1 && cabbage == 1
#Все прочие типы транзакций запрещены
case _ => false
}
PHP ಮೊದಲು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಿಂದ ಎಲ್ಲಾ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಅವುಗಳ ಕೀಗಳ ರೂಪದಲ್ಲಿ ಮತ್ತು ಅನುಗುಣವಾದ ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಹೊರತೆಗೆಯುತ್ತದೆ.
cabbage: extract ( getInteger ( contract , "cabbage" ) )
goat: extract ( getInteger ( contract , "goat" ) )
human: extract ( getInteger ( contract , "human" ) )
wolf: extract ( getInteger ( contract , "wolf" ) )
fState: human== 1 && wolf== 1 && goat== 1 && cabbage== 1
fState:
wolf:
goat:
cabbage:
cabbageSide: cabbage== 0 || cabbage== 1
human: extract ( getInteger ( contract , "human" ) )
newGoat: extract ( getInteger ( t.data , "goat" ) )
newHuman: extract ( getInteger ( t.data , "human" ) )
goatSide: goat== 0 || goat== 1
humanSide: human== 0 || human== 1
t7: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage
t3: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage + 1
t6: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage - 1
t2: humanTravel && newWolf== wolf && newGoat== goat + 1 && newCabbage== cabbage
t5: humanTravel && newWolf== wolf && newGoat== goat - 1 && newCabbage== cabbage
t1: humanTravel && newWolf== wolf + 1 && newGoat== goat && newCabbage== cabbage
t4: humanTravel && newWolf== wolf - 1 && newGoat== goat && newCabbage== cabbage
safeAlone: newGoat != newWolf && newGoat != newCabbage
wolfSide: wolf== 0 || wolf== 1
humanTravel: human != newHuman
side: humanSide && wolfSide && goatSide && cabbageSide
safe: safeAlone || newGoat== newHuman
objectTravel: t1 || t2 || t3 || t4 || t5 || t6 || t7
PHP ನಂತರ ಅವುಗಳನ್ನು ಪೈಥಾನ್‌ನಲ್ಲಿ Z3Prover SMT-ಹೊಂದಾಣಿಕೆಯ ಸಿಸ್ಟಮ್ ವಿವರಣೆಯಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಡೇಟಾವನ್ನು ಲೂಪ್‌ನಲ್ಲಿ ಸುತ್ತಿಡಲಾಗುತ್ತದೆ, ಅಲ್ಲಿ ಶೇಖರಣಾ ವೇರಿಯೇಬಲ್‌ಗಳು ಸೂಚ್ಯಂಕ i, ವಹಿವಾಟು ವೇರಿಯೇಬಲ್‌ಗಳ ಸೂಚ್ಯಂಕ i + 1 ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಗಳೊಂದಿಗೆ ವೇರಿಯಬಲ್‌ಗಳು ಹಿಂದಿನ ಸ್ಥಿತಿಯಿಂದ ಮುಂದಿನ ಸ್ಥಿತಿಗೆ ಪರಿವರ್ತನೆಯ ನಿಯಮಗಳನ್ನು ಹೊಂದಿಸುತ್ತವೆ.
ಇದು ನಮ್ಮ ವರ್ಚುವಲ್ ಯಂತ್ರದ ಹೃದಯವಾಗಿದೆ, ಇದು ಬಹು-ವಹಿವಾಟು ಹುಡುಕಾಟ ಕಾರ್ಯವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.
fState: And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final: fState[Steps]
fState:
wolf:
goat:
cabbage:
cabbageSide: Or( cabbage[i] == 0 , cabbage[i] == 1 )
goatSide: Or( goat[i] == 0 , goat[i] == 1 )
humanSide: Or( human[i] == 0 , human[i] == 1 )
t7: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t3: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] + 1 )
t6: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] - 1 )
t2: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage == cabbage[i] )
t5: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage == cabbage[i] )
t1: And( And( And( humanTravel[i] , wolf == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t4: And( And( And( humanTravel[i] , wolf == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
safeAlone: And( goat[i+1] != wolf , goat[i+1] != cabbage )
wolfSide: Or( wolf[i] == 0 , wolf[i] == 1 )
humanTravel: human[i] != human[i+1]
side: And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] )
safe: Or( safeAlone[i] , goat[i+1] == human[i+1] )
objectTravel: Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] )
data: And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] )
ಪೈಥಾನ್‌ನಲ್ಲಿ SMT ವ್ಯವಸ್ಥೆಯನ್ನು ವಿವರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪ್ಲೇಟ್‌ಗೆ ಷರತ್ತುಗಳನ್ನು ವಿಂಗಡಿಸಲಾಗಿದೆ ಮತ್ತು ಸೇರಿಸಲಾಗುತ್ತದೆ.
ಖಾಲಿ ಟೆಂಪ್ಲೇಟ್
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
$code$
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
ಸಂಪೂರ್ಣ ಸರಪಳಿಯ ಕೊನೆಯ ಸ್ಥಿತಿಗೆ, ವರ್ಗಾವಣೆ ವಹಿವಾಟು ವಿಭಾಗದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಿಯಮಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
ಇದರರ್ಥ Z3Prover ನಿಖರವಾಗಿ ಅಂತಹ ಷರತ್ತುಗಳನ್ನು ಹುಡುಕುತ್ತದೆ, ಅದು ಅಂತಿಮವಾಗಿ ಒಪ್ಪಂದದಿಂದ ಹಣವನ್ನು ಹಿಂಪಡೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಪರಿಣಾಮವಾಗಿ, ನಮ್ಮ ಒಪ್ಪಂದದ ಸಂಪೂರ್ಣ ಕ್ರಿಯಾತ್ಮಕ SMT ಮಾದರಿಯನ್ನು ನಾವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ವೀಕರಿಸುತ್ತೇವೆ.
ನಾನು ಕೈಯಾರೆ ಸಂಕಲಿಸಿದ ನನ್ನ ಹಿಂದಿನ ಲೇಖನದ ಮಾದರಿಗೆ ಇದು ಹೋಲುತ್ತದೆ ಎಂದು ನೀವು ನೋಡಬಹುದು.
ಪೂರ್ಣಗೊಂಡ ಟೆಂಪ್ಲೇಟ್
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
human = [ Int('human_%i' % (i + 1)) for i in range(Num) ]
wolf = [ Int('wolf_%i' % (i + 1)) for i in range(Num) ]
goat = [ Int('goat_%i' % (i + 1)) for i in range(Num) ]
cabbage = [ Int('cabbage_%i' % (i + 1)) for i in range(Num) ]
nothing= [ And( human[i] == human[i+1], wolf[i] == wolf[i+1], goat[i] == goat[i+1], cabbage[i] == cabbage[i+1] ) for i in range(Num-1) ]
start= [ human[0] == 1, wolf[0] == 0, goat[0] == 1, cabbage[0] == 0 ]
safeAlone= [ And( goat[i+1] != wolf[i+1] , goat[i+1] != cabbage[i+1] ) for i in range(Num-1) ]
safe= [ Or( safeAlone[i] , goat[i+1] == human[i+1] ) for i in range(Num-1) ]
humanTravel= [ human[i] != human[i+1] for i in range(Num-1) ]
cabbageSide= [ Or( cabbage[i] == 0 , cabbage[i] == 1 ) for i in range(Num-1) ]
goatSide= [ Or( goat[i] == 0 , goat[i] == 1 ) for i in range(Num-1) ]
humanSide= [ Or( human[i] == 0 , human[i] == 1 ) for i in range(Num-1) ]
t7= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t3= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] + 1 ) for i in range(Num-1) ]
t6= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] - 1 ) for i in range(Num-1) ]
t2= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t5= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t1= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t4= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
wolfSide= [ Or( wolf[i] == 0 , wolf[i] == 1 ) for i in range(Num-1) ]
side= [ And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] ) for i in range(Num-1) ]
objectTravel= [ Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] ) for i in range(Num-1) ]
data= [ Or( And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] ) , nothing[i]) for i in range(Num-1) ]
fState= And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final= fState
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
ಪ್ರಾರಂಭದ ನಂತರ, Z3Prover ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಪರಿಹರಿಸುತ್ತದೆ ಮತ್ತು ಹಣವನ್ನು ಹಿಂಪಡೆಯಲು ನಮಗೆ ಅನುಮತಿಸುವ ವಹಿವಾಟುಗಳ ಸರಣಿಯನ್ನು ನಮಗೆ ಒದಗಿಸುತ್ತದೆ:
Winning transaction chain found:
Data transaction: human= 0, wolf= 0, goat= 1, cabbage= 0
Data transaction: human= 1, wolf= 0, goat= 1, cabbage= 1
Data transaction: human= 0, wolf= 0, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 0, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Transfer transaction
ದೋಣಿ ಒಪ್ಪಂದದ ಜೊತೆಗೆ, ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಒಪ್ಪಂದಗಳೊಂದಿಗೆ ಪ್ರಯೋಗಿಸಬಹುದು ಅಥವಾ ಈ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪ್ರಯತ್ನಿಸಬಹುದು, ಇದನ್ನು 2 ವಹಿವಾಟುಗಳಲ್ಲಿ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ.
let contract = tx.sender
let a= extract(getInteger(contract,"a"))
let b= extract(getInteger(contract,"b"))
let c= extract(getInteger(contract,"c"))
let d= extract(getInteger(contract,"d"))
match tx {
case t:DataTransaction =>
let na= extract(getInteger(t.data,"a"))
let nb= extract(getInteger(t.data,"b"))
let nc= extract(getInteger(t.data,"c"))
let nd= extract(getInteger(t.data,"d"))
nd == 0 || a == 100 - 5
case s:TransferTransaction =>
( a + b - c ) * d == 12
case _ => true
}
ಇದು ಮೊದಲ ಆವೃತ್ತಿಯಾಗಿರುವುದರಿಂದ, ಸಿಂಟ್ಯಾಕ್ಸ್ ತುಂಬಾ ಸೀಮಿತವಾಗಿದೆ ಮತ್ತು ದೋಷಗಳು ಇರಬಹುದು.
ಮುಂದಿನ ಲೇಖನಗಳಲ್ಲಿ, ನಾನು VM ನ ಮತ್ತಷ್ಟು ಅಭಿವೃದ್ಧಿಯನ್ನು ಒಳಗೊಳ್ಳಲು ಯೋಜಿಸುತ್ತೇನೆ ಮತ್ತು ಅದರ ಸಹಾಯದಿಂದ ನೀವು ಔಪಚಾರಿಕವಾಗಿ ಪರಿಶೀಲಿಸಿದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ಹೇಗೆ ರಚಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತೇನೆ ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿಹರಿಸುವುದಿಲ್ಲ.
ಅಕ್ಷರ ವರ್ಚುವಲ್ ಯಂತ್ರವು ಇಲ್ಲಿ ಲಭ್ಯವಿದೆ
ಸಾಂಕೇತಿಕ VM ನ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಕ್ರಮವಾಗಿ ಇರಿಸಿ ಮತ್ತು ಅಲ್ಲಿ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಿದ ನಂತರ, ಉಚಿತ ಪ್ರವೇಶಕ್ಕಾಗಿ ಅದನ್ನು GitHub ನಲ್ಲಿ ಹಾಕಲು ನಾನು ಯೋಜಿಸುತ್ತೇನೆ.
ಮೂಲ: www.habr.com