[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6H9SH8HB05WZWMPD9BF2NT7":3,"skill-same:01M6H9SH8HB05WZWMPD9BF2NT7":56},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":27,"linkOnly":28,"markdownContent":29,"markdownBody":30,"frontMatter":31,"refName":34,"commitSha":35,"skillDirectory":36,"forksCount":14,"repositoryHtmlUrl":37,"repositoryHomepageUrl":6,"ownerHtmlUrl":38,"ownerBlogUrl":39,"ownerDescription":40,"updatedAt":41,"install":42,"resources":55},"01M6H9SH8HB05WZWMPD9BF2NT7","formal-methods",null,"Formal verification methods","NeuralBlitz\u002FMito","NeuralBlitz","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F79354388?v=4","01M6H8T2TFH477HRS0KTSTKR2E","David Riggs","01M6H8T2YQQDXPYM092P670Z21",0,"MIT","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fformal-methods\u002FSKILL.md",[],[19,20,21,22,23,24,25,26],"methods","formal methods","verification","science","computer","opencode","formal verification","computer-science","2026-11-10 10:12:30",false,"---\nname: formal-methods\ndescription: Formal verification methods\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: developers\n  category: computer-science\n---\n\n## What I do\n- Specify system behavior formally\n- Verify correctness of algorithms\n- Prove properties about programs\n- Model check systems\n\n## When to use me\nWhen building high-assurance systems where correctness is critical.\n\n## Formal Specification\n\n### Pre\u002FPost Conditions\n```python\nclass FormalSpec:\n    \"\"\"Design by contract\"\"\"\n    \n    def requires(self, *conditions):\n        \"\"\"Precondition decorator\"\"\"\n        def decorator(func):\n            def wrapper(*args, **kwargs):\n                for i, cond in enumerate(conditions):\n                    if not cond(args[i] if i \u003C len(args) else None):\n                        raise PreconditionViolation(\n                            f\"Precondition {cond.__name__} failed\"\n                        )\n                return func(*args, **kwargs)\n            return wrapper\n        return decorator\n    \n    def ensures(self, *conditions):\n        \"\"\"Postcondition decorator\"\"\"\n        def decorator(func):\n            def wrapper(*args, **kwargs):\n                result = func(*args, **kwargs)\n                for cond in conditions:\n                    if not cond(result):\n                        raise PostconditionViolation(\n                            f\"Postcondition {cond.__name__} failed\"\n                        )\n                return result\n            return wrapper\n        return decorator\n\n\n# Example: Sorted list specification\ndef is_sorted(lst: list) -> bool:\n    \"\"\"Postcondition: list is sorted\"\"\"\n    for i in range(len(lst) - 1):\n        if lst[i] > lst[i + 1]:\n            return False\n    return True\n\n\ndef non_negative(x: int) -> bool:\n    \"\"\"Precondition: x is non-negative\"\"\"\n    return x >= 0\n\n\ndef sorted_insert(lst: list, x: int) -> list:\n    \"\"\"Insert x into sorted list lst\"\"\"\n    result = lst + [x]\n    result.sort()\n    return result\n```\n\n### Invariants\n```python\nclass Invariant:\n    \"\"\"Class and loop invariants\"\"\"\n    \n    @staticmethod\n    def class_invariant(cls):\n        \"\"\"Decorator for class invariant\"\"\"\n        original_init = cls.__init__\n        \n        def new_init(self, *args, **kwargs):\n            original_init(self, *args, **kwargs)\n            if not cls.invariant(self):\n                raise InvariantViolation(\"Class invariant violated\")\n        \n        cls.__init__ = new_init\n        \n        # Check invariant after each public method\n        original_methods = [m for m in dir(cls) \n                          if not m.startswith('_') \n                          and callable(getattr(cls, m))]\n        \n        for method_name in original_methods:\n            original_method = getattr(cls, method_name)\n            \n            def make_wrapper(method):\n                def wrapper(self, *args, **kwargs):\n                    result = method(self, *args, **kwargs)\n                    if not cls.invariant(self):\n                        raise InvariantViolation(\n                            f\"Invariant violated after {method_name}\"\n                        )\n                    return result\n                return wrapper\n            \n            setattr(cls, method_name, make_wrapper(original_method))\n        \n        return cls\n\n\n# Example: Stack invariant\n@Invariant\nclass Stack:\n    def __init__(self, capacity: int):\n        self.items = []\n        self.capacity = capacity\n    \n    def invariant(self):\n        \"\"\"Stack invariant\"\"\"\n        return (\n            len(self.items) >= 0 and\n            len(self.items) \u003C= self.capacity\n        )\n    \n    def push(self, item):\n        if len(self.items) >= self.capacity:\n            raise OverflowError(\"Stack overflow\")\n        self.items.append(item)\n    \n    def pop(self):\n        if not self.items:\n            raise IndexError(\"Stack underflow\")\n        return self.items.pop()\n```\n\n### Formal Verification\n\n### Hoare Logic\n```python\nclass HoareTriple:\n    \"\"\"Hoare logic for program verification\"\"\"\n    \n    @staticmethod\n    def verify(Pre: Callable, program: Callable, \n              Post: Callable) -> bool:\n        \"\"\"Verify Hoare triple: {P} program {Q}\"\"\"\n        # In practice, use theorem prover\n        pass\n    \n    @staticmethod\n    def assignment(x: str, expr: str, post: str) -> str:\n        \"\"\"Hoare rule for assignment: {Q[x\u002FE]} x := E {Q}\"\"\"\n        return f\"{{{post.replace(x, expr)}}}\"\n    \n    @staticmethod\n    def sequence(stmts: List[str], pre: str, post: str) -> str:\n        \"\"\"Hoare rule for sequence\"\"\"\n        # {P} S1; S2 {R} from {P} S1 {Q}; {Q} S2 {R}\n        return pre\n    \n    @staticmethod\n    def conditional(pre: str, cond: str, \n                   post_then: str, post_else: str) -> str:\n        \"\"\"Hoare rule for if\"\"\"\n        # {P} if B then {Q} else {R} from {P && B} S1 {Q} and {P && !B} S2 {R}\n        return f\"{{{pre}}}\"\n```\n\n### Model Checking\n```python\nclass ModelChecker:\n    \"\"\"Simple model checker\"\"\"\n    \n    def __init__(self):\n        self.states = set()\n        self.transitions = {}\n        self.properties = []\n    \n    def add_state(self, state: str):\n        self.states.add(state)\n    \n    def add_transition(self, from_state: str, to_state: str, \n                      action: str):\n        if from_state not in self.transitions:\n            self.transitions[from_state] = []\n        self.transitions[from_state].append((action, to_state))\n    \n    def check_reachability(self, start: str, goal: str) -> bool:\n        \"\"\"Check if goal is reachable from start\"\"\"\n        visited = set()\n        stack = [start]\n        \n        while stack:\n            state = stack.pop()\n            if state == goal:\n                return True\n            if state in visited:\n                continue\n            \n            visited.add(state)\n            \n            for _, next_state in self.transitions.get(state, []):\n                stack.append(next_state)\n        \n        return False\n    \n    def check_liveness(self, start: str, good_states: Set[str]) -> bool:\n        \"\"\"Check liveness: eventually reach good state\"\"\"\n        visited = set()\n        stack = [start]\n        \n        while stack:\n            state = stack.pop()\n            if state in visited:\n                continue\n            \n            visited.add(state)\n            \n            if state in good_states:\n                return True\n            \n            for _, next_state in self.transitions.get(state, []):\n                stack.append(next_state)\n        \n        return False\n    \n    def check_safety(self, start: str, \n                    bad_states: Set[str]) -> bool:\n        \"\"\"Check safety: never reach bad state\"\"\"\n        return not self.check_reachability(start, \n            bad_states.pop() if bad_states else None)\n```\n","## What I do\n- Specify system behavior formally\n- Verify correctness of algorithms\n- Prove properties about programs\n- Model check systems\n\n## When to use me\nWhen building high-assurance systems where correctness is critical.\n\n## Formal Specification\n\n### Pre\u002FPost Conditions\n```python\nclass FormalSpec:\n    \"\"\"Design by contract\"\"\"\n    \n    def requires(self, *conditions):\n        \"\"\"Precondition decorator\"\"\"\n        def decorator(func):\n            def wrapper(*args, **kwargs):\n                for i, cond in enumerate(conditions):\n                    if not cond(args[i] if i \u003C len(args) else None):\n                        raise PreconditionViolation(\n                            f\"Precondition {cond.__name__} failed\"\n                        )\n                return func(*args, **kwargs)\n            return wrapper\n        return decorator\n    \n    def ensures(self, *conditions):\n        \"\"\"Postcondition decorator\"\"\"\n        def decorator(func):\n            def wrapper(*args, **kwargs):\n                result = func(*args, **kwargs)\n                for cond in conditions:\n                    if not cond(result):\n                        raise PostconditionViolation(\n                            f\"Postcondition {cond.__name__} failed\"\n                        )\n                return result\n            return wrapper\n        return decorator\n\n\n# Example: Sorted list specification\ndef is_sorted(lst: list) -> bool:\n    \"\"\"Postcondition: list is sorted\"\"\"\n    for i in range(len(lst) - 1):\n        if lst[i] > lst[i + 1]:\n            return False\n    return True\n\n\ndef non_negative(x: int) -> bool:\n    \"\"\"Precondition: x is non-negative\"\"\"\n    return x >= 0\n\n\ndef sorted_insert(lst: list, x: int) -> list:\n    \"\"\"Insert x into sorted list lst\"\"\"\n    result = lst + [x]\n    result.sort()\n    return result\n```\n\n### Invariants\n```python\nclass Invariant:\n    \"\"\"Class and loop invariants\"\"\"\n    \n    @staticmethod\n    def class_invariant(cls):\n        \"\"\"Decorator for class invariant\"\"\"\n        original_init = cls.__init__\n        \n        def new_init(self, *args, **kwargs):\n            original_init(self, *args, **kwargs)\n            if not cls.invariant(self):\n                raise InvariantViolation(\"Class invariant violated\")\n        \n        cls.__init__ = new_init\n        \n        # Check invariant after each public method\n        original_methods = [m for m in dir(cls) \n                          if not m.startswith('_') \n                          and callable(getattr(cls, m))]\n        \n        for method_name in original_methods:\n            original_method = getattr(cls, method_name)\n            \n            def make_wrapper(method):\n                def wrapper(self, *args, **kwargs):\n                    result = method(self, *args, **kwargs)\n                    if not cls.invariant(self):\n                        raise InvariantViolation(\n                            f\"Invariant violated after {method_name}\"\n                        )\n                    return result\n                return wrapper\n            \n            setattr(cls, method_name, make_wrapper(original_method))\n        \n        return cls\n\n\n# Example: Stack invariant\n@Invariant\nclass Stack:\n    def __init__(self, capacity: int):\n        self.items = []\n        self.capacity = capacity\n    \n    def invariant(self):\n        \"\"\"Stack invariant\"\"\"\n        return (\n            len(self.items) >= 0 and\n            len(self.items) \u003C= self.capacity\n        )\n    \n    def push(self, item):\n        if len(self.items) >= self.capacity:\n            raise OverflowError(\"Stack overflow\")\n        self.items.append(item)\n    \n    def pop(self):\n        if not self.items:\n            raise IndexError(\"Stack underflow\")\n        return self.items.pop()\n```\n\n### Formal Verification\n\n### Hoare Logic\n```python\nclass HoareTriple:\n    \"\"\"Hoare logic for program verification\"\"\"\n    \n    @staticmethod\n    def verify(Pre: Callable, program: Callable, \n              Post: Callable) -> bool:\n        \"\"\"Verify Hoare triple: {P} program {Q}\"\"\"\n        # In practice, use theorem prover\n        pass\n    \n    @staticmethod\n    def assignment(x: str, expr: str, post: str) -> str:\n        \"\"\"Hoare rule for assignment: {Q[x\u002FE]} x := E {Q}\"\"\"\n        return f\"{{{post.replace(x, expr)}}}\"\n    \n    @staticmethod\n    def sequence(stmts: List[str], pre: str, post: str) -> str:\n        \"\"\"Hoare rule for sequence\"\"\"\n        # {P} S1; S2 {R} from {P} S1 {Q}; {Q} S2 {R}\n        return pre\n    \n    @staticmethod\n    def conditional(pre: str, cond: str, \n                   post_then: str, post_else: str) -> str:\n        \"\"\"Hoare rule for if\"\"\"\n        # {P} if B then {Q} else {R} from {P && B} S1 {Q} and {P && !B} S2 {R}\n        return f\"{{{pre}}}\"\n```\n\n### Model Checking\n```python\nclass ModelChecker:\n    \"\"\"Simple model checker\"\"\"\n    \n    def __init__(self):\n        self.states = set()\n        self.transitions = {}\n        self.properties = []\n    \n    def add_state(self, state: str):\n        self.states.add(state)\n    \n    def add_transition(self, from_state: str, to_state: str, \n                      action: str):\n        if from_state not in self.transitions:\n            self.transitions[from_state] = []\n        self.transitions[from_state].append((action, to_state))\n    \n    def check_reachability(self, start: str, goal: str) -> bool:\n        \"\"\"Check if goal is reachable from start\"\"\"\n        visited = set()\n        stack = [start]\n        \n        while stack:\n            state = stack.pop()\n            if state == goal:\n                return True\n            if state in visited:\n                continue\n            \n            visited.add(state)\n            \n            for _, next_state in self.transitions.get(state, []):\n                stack.append(next_state)\n        \n        return False\n    \n    def check_liveness(self, start: str, good_states: Set[str]) -> bool:\n        \"\"\"Check liveness: eventually reach good state\"\"\"\n        visited = set()\n        stack = [start]\n        \n        while stack:\n            state = stack.pop()\n            if state in visited:\n                continue\n            \n            visited.add(state)\n            \n            if state in good_states:\n                return True\n            \n            for _, next_state in self.transitions.get(state, []):\n                stack.append(next_state)\n        \n        return False\n    \n    def check_safety(self, start: str, \n                    bad_states: Set[str]) -> bool:\n        \"\"\"Check safety: never reach bad state\"\"\"\n        return not self.check_reachability(start, \n            bad_states.pop() if bad_states else None)\n```\n",{"name":5,"license":15,"metadata":32,"description":7,"compatibility":24},{"audience":33,"category":26},"developers","main","2ea764e153842704d24a2e9aa4170441a7f03081",".opencode\u002Fskills\u002Fformal-methods","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito","https:\u002F\u002Fgithub.com\u002FNeuralBlitz","nuralnexus.org","Theoretical and Futuristic AI Nerd 🤓 ","2026-11-12 03:13:05",{"source":8,"skillName":5,"commands":43,"prompt":53,"zipAvailable":54},[44,47,50],{"tool":45,"command":46},"npx","npx skills add NeuralBlitz\u002FMito --skill formal-methods",{"tool":48,"command":49},"bunx","bunx skills add NeuralBlitz\u002FMito --skill formal-methods",{"tool":51,"command":52},"pnpm","pnpm dlx skills add NeuralBlitz\u002FMito --skill formal-methods","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fformal-methods\u002FSKILL.md",true,[],[57,73,86,99,107,131],{"skillNo":58,"name":59,"nameZh":6,"description":60,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":61,"categories":62,"keywords":63,"publishedAt":27},"01M6HAZSAQK1S27CEZYAYJTQDX","wireless-communications","Wireless systems, mobile networks, and 5G\u002F6G","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwireless-communications\u002FSKILL.md",[],[64,65,66,67,68,69,70,71,24,72],"communications","wireless communications","wireless","systems","engineering","networks","5G","students","mobile",{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":27},"01M6HAZFX6E8NK3WZWDX5YCKYY","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwebassembly\u002Fwebsockets\u002FSKILL.md",[],[75,80,81,82,24,83,84,85],"websocket implementation","time","implementation","real-time","websocket","best practices",{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":27},"01M6HAZ6DAXBQ7QHXXM1EM7715","vulnerability-auditing","Vulnerability assessment and auditing","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvulnerability-auditing\u002FSKILL.md",[],[93,94,95,96,24,97,98],"vulnerability","vulnerability auditing","security","vulnerability assessment","cybersecurity","assessment",{"skillNo":100,"name":101,"nameZh":6,"description":102,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":103,"categories":104,"keywords":105,"publishedAt":27},"01M6HAZ3FKF3CS9Z3J96RVE2ZE","vulnerability-assessment","Finding and assessing security vulnerabilities","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvue\u002Fvulnerability-assessment\u002FSKILL.md",[],[96,93,98,95,106,24],"vulnerabilities",{"skillNo":108,"name":109,"nameZh":6,"description":110,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":111,"categories":112,"keywords":123,"publishedAt":27},"01M6HAYSHM6HKRKEHFP0SGZQX7","vlsi-design","Very-Large-Scale Integration circuit design and semiconductor engineering","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvlsi-design\u002FSKILL.md",[113,118],{"categoryNo":114,"categoryName":115,"taxonomyType":116,"taxonomyTypeDesc":117},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":119,"categoryName":120,"taxonomyType":121,"taxonomyTypeDesc":122},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[124,125,126,127,128,68,23,24,129,71,130],"vlsi design","VLSI","design","hardware","integration","scale","circuit",{"skillNo":132,"name":133,"nameZh":6,"description":134,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":135,"categories":136,"keywords":137,"publishedAt":27},"01M6HAYPQ30FFE2JXD7WQJ8R6C","unsupervised","Unsupervised learning concepts","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvisualization\u002Funsupervised\u002FSKILL.md",[],[133,138,24,139,140,141,142,143],"learning","intelligence","unsupervised learning","machine","concepts","machine-learning"]