[{"_1":2,"_168":-5,"_169":-5},"loaderData",{"_3":4,"_13":14,"_21":22,"_143":144},"root",{"_5":-5,"_6":-7,"_7":8,"_9":-7,"_10":11,"_12":-7},"currentUser","primaryEmail","siteVerification","6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI","toast","enableDev",false,"incidentStatus","routes/_layout",{"_15":-5,"_16":17,"_18":17,"_19":11,"_20":17},"username","isAskGordonEnabled",true,"isUsingNewTemplate","showMinimalLanding","showHoneypotTrap","routes/_layout.r.$namespace.$reponame",{"_23":24,"_25":-5,"_26":11,"_27":11,"_28":29,"_30":31,"_32":-5,"_33":11,"_34":35,"_84":-5,"_85":86,"_134":-5,"_135":11,"_136":17,"_137":11,"_138":-5,"_139":11,"_140":-5,"_141":142},"canonicalUrl","https://hub.docker.com/r/abueide/dig/tags","mcpServer","canSeeDockerfile","canSeeAutobuilds","namespace","abueide","reponame","dig","cloudBuildSource","isAutobuildsAvailable","repo",{"_36":37,"_38":39,"_41":42,"_43":44,"_45":11,"_46":47,"_48":49,"_50":51,"_53":31,"_28":29,"_54":55,"_56":40,"_57":58,"_59":60,"_61":62,"_63":-5,"_64":58,"_65":66,"_67":11,"_68":29,"_69":70,"_75":11,"_76":77,"_81":29,"_82":83},"categories",[],"content_types",[40],"image","date_registered","2021-03-28T06:30:30.883943Z","description","","is_private","last_updated","2021-03-28T07:43:34.932696Z","last_modified","2024-10-16T13:48:34.145251Z","media_types",[52],"application/vnd.docker.container.image.v1+json","name","pull_count",337,"repository_type","star_count",0,"status",1,"status_description","active","source","collaborator_count","full_description","# DIG\n\n**DIG** is a tool for generating program invariants at arbitrary program locations (e.g., loop invariants, post conditions, etc). DIG infers (potentially **nonlinear**) numerical invariants using symbolic states extracted from a symbolic execution tool. DIG supports equalities such as `x+y=5`, `x*y=z`, `x*3y^3 + 2*zw + pq + q^3 = 3`, inequalities such as `x <= y^2 + 3`, and min/max inequalities such as `max(x,y) <= z + 2`. The user can also use *terms* to represent desired information, e.g., `t = 2^x`, and have DIG infer invariants over terms.\n\nDIG's numerical relations (in particular, nonlinear equalities) have been used for\n- nonlinear program understanding and correctness checking (`ICSE12`, `ICSE14`, `ASE17`, `FSE17`, `TOSEM13`)\n- complexity analysis (e.g., providing program run time complexity such as `O(N^2)` or `O(NM)`, `ASE17`, `FSE17`)\n- recurrence relations for complexity analysis (e.g., finding recurrence relations for recursive programs such as `T(n)=3*T(n/2) + f(n)`, `SEAD20`)\n- termination and non-termination analyses (use nonlinear invariants to reason about ranking function for termination and recurrent sets for non-termination, `OOPSLA20`)\n- array analysis (finding invariant relations over array data structures, e.g., `A[i] = B[C[2i + 3]]`, `ICSE12`, `TOSEM13`)\n\nDIG is written in Python using the **SAGE** mathematics system. It infers invariants using dynamic execution (over execution traces) and checks those invariants using symbolic states and constraint solving.\nDIG uses symbolic execution (**Symbolic PathFinder** for Java and **CIVL** for C) to collect symbolic states and the **Z3** SMT solver for constraint solving.\n\nThe current version of DIG works with programs written in Java, Java bytecode, and C. The tool also infers invariants direclty from given concrete program execution traces.\n\n---\n\n## Usage\n\nYou can use DIG to generate invariants from a [program](#generating-invariants-from-a-program) (either a Java file `.java`, a bytecode file `.class`, or a C file `.c`), or a [trace file](#generating-invariants-from-traces) (a plain text file consisting of concrete values of variables).\n\n### Generating Invariants From a Program\n\nConsider the following `CohenDiv.java` program\n\n```java\n// in DIG's src directory\n// $ less ../test/nla/CohenDiv.java\n\npublic class CohenDiv {\n public static void vtrace0(int q, int r, int a, int b, int x, int y){}\n public static void vtrace1(int q, int r, int a, int b, int x, int y){}\n public static void vtrace2(int x, int y, int q, int r){}\n\n public static void main (String[] args) {}\n public static int mainQ(int x, int y) {\n assert(x >= 0);\n assert(y >= 1);\n\n int q=0;\n int r=x;\n int a=0;\n int b=0;\n\n while(true) {\n vtrace0(q,r,a,b,x,y);\n if(!(r>=y)) break;\n a=1;\n b=y;\n\n while (true) {\n vtrace1(q,r,a,b,x,y);\n if(!(r >= 2*b)) break;\n\n a = 2*a;\n b = 2*b;\n }\n r=r-b;\n q=q+a;\n }\n\n vtrace2(x,y,q,r);\n return q;\n }\n}\n\n```\n\n* To find invariants at some location, we declare a function `vtraceX` where `X` is some distinct number and call that function at that location.\n * For example, in `CohenDiv.java`, we call `vtrace0`, `vtrace1` at the head of the outter and inner while loops find loop invariants and `vtrace2` before the function exit to find post conditions.\n * `vtraceX` takes a list of arguments that are variables in scope at the desired location. This tells DIG to find invariants over these variables.\n\n* Next, we run DIG on `CohenDiv.java` or its byteclass version (compiled with `javac -g`) and discover the following invariants at `vtracesX` locations:\n\n```sh\n# in DIG's src directory\ntnguyen@origin ~/d/src (dev)> sage -python -O dig.py ../tests/paper/CohenDiv.java -log 3\nsettings:INFO:2020-10-03 21:39:01.995144: dig.py ../tests/paper/CohenDiv.java -log 3\nalg:INFO:analyze '../tests/paper/CohenDiv.java'\nalg:INFO:compute symbolic states (18.65s)\nalg:INFO:infer invs at 3 locs: vtrace0, vtrace2, vtrace1\nalg:INFO:found 5 eqts (26.55s)\nalg:INFO:found 67 ieqs (1.10s)\nalg:INFO:found 377 minmax (2.55s)\nalg:INFO:test 449 invs using 699 traces (0.93s)\nalg:INFO:simplify 449 invs (1.79s)\n* prog CohenDiv locs 3; invs 25 (Eqt: 5, MP: 1, Oct: 19) V 6 T 3 D 2; NL 5 (2) ;\n-> time eqts 26.5s, ieqs 1.1s, minmax 2.5s, simplify 2.7s, symbolic_states 18.7s, total 51.9s\n-> checks 0 () change depths 0 () change vals 0 ()\n-> max 0 () change depths 0 ()\nruns 1\nrand seed 1601779141.99, test (6, 59)\nvtrace0 (11 invs):\n1. a*y - b == 0\n2. q*y + r - x == 0\n3. -r <= 0\n4. -a <= 0\n5. a - b <= 0\n6. a - q <= 0\n7. q - x <= 0\n8. r - x <= 0\n9. b - x <= 0\n10. -a - y <= -1\n11. min(q, y) - b <= 0\nvtrace1 (8 invs):\n1. a*y - b == 0\n2. q*y + r - x == 0\n3. -q <= 0\n4. b - r <= 0\n5. a - b <= 0\n6. r - x <= 0\n7. -b + y <= 0\n8. -a - y <= -2\nvtrace2 (6 invs):\n1. q*y + r - x == 0\n2. -r <= 0\n3. -q <= 0\n4. q - x <= 0\n5. r - x <= 0\n6. r - y <= -1\ntmpdir: /var/tmp/dig_2282784602713568709_x0qxjt3s\n```\n\n### Other programs\n\n* The directory `../benchmarks/java/nla` contains many programs having nonlinear invariants.\n\n### Generating Invariants From Traces\n\nDIG can infer invariants directly from a file consisting of concreting program execution traces. Below is an example of traces generated when running the above `CohenDiv` program with various inputs\n\n```sh\n# in DIG's src directory\n$ less ../test/traces/CohenDiv.tcs\nvtrace1: I q, I r, I a, I b, I x, I y\nvtrace1: 4, 8, 1, 4, 24, 4\nvtrace1: 16, 89, 1, 13, 297, 13\nvtrace1: 8, 138, 4, 76, 290, 19\nvtrace1: 0, 294, 8, 192, 294, 24\nvtrace1: 64, 36, 4, 16, 292, 4\n...\nvtrace2: I x, I y, I q, I r\nvtrace2: 280, 24, 11, 16\nvtrace2: 352, 11, 32, 0\nvtrace2: 22, 298, 0, 22\nvtrace2: 274, 275, 0, 274\nvtrace2: 2, 287, 0, 2\n...\n```\n\n```sh\n# in DIG's src directory\ntnguyen@debian ~/d/src> sage -python -O dig.py ../tests/traces/CohenDiv.tcs -log 3\nsettings:INFO:2020-06-30 15:26:53.384339: dig.py ../tests/traces/CohenDiv.tcs -log 3\nalg:INFO:analyze '../tests/traces/CohenDiv.tcs'\nalg:INFO:test 30 invs using 181 traces (0.96s)\nalg:INFO:simplify 26 invs (0.42s)\nvtrace1 (6 invs):\nvtrace1 (8 invs):\n1. q*y + r - x == 0\n2. -q <= 0\n3. -r <= 0\n4. -y <= -1\n5. r - x <= 0\n6. q - x <= 0\n7. -r - x <= -2\n8. -x - y <= -10\nvtrace2 (8 invs):\n1. q*y + r - x == 0\n2. -q <= 0\n3. -r <= 0\n4. r - x <= 0\n5. q - x <= 0\n6. r - y <= -1\n7. -r - x <= -2\n8. -x - y <= -10\n....\n```\n\nNote that if we just run Dig over traces, then most of the generated inequality results are spurious, i.e., they are correct with the given traces, but not real invariants. If given the program source code as [shown above](#generating-invariants-from-a-program), DIG can check and remove spurious results.\n\n### Additional Options\n\nMost of DIG's behaviors can be controlled by the users (the `src\\settings.py` lists all the defaut parameters). Use `-h` or `--help` to see options that can be passed into DIG. Below we show several ones\n\n#### Specify max degree for equalities\n\nBy default, DIG automatically to find equalities up to certain degree. We can specify this degree directly with `-maxdeg X`\n\n```sh\ntnguyen@debian ~/dig/src> sage -python -O dig.py ../tests/paper/CohenDiv.java -log 3 -maxdeg 2 -noieqs #find equalities up to degree 2 and donot infer inequalities\n...\n```\n\n#### Customizing Inequalities\n\nBy default, DIG infers octagonal inequalities (i.e., linear inequalities among 2 variables with coefs in in the set {-1,0,1}). But we can customize DIG to find more expression inequalities (of course, with the trade-off that it takes more time to generate more expressive invs).\n\nBelow we use a different example `Sqrt1.java` to demonstrate\n\n```sh\ntnguyen@debian ~/dig/src> sage -python -O dig.py ../tests/paper/CohenDiv.java -log 3 -noeqts # for demonstration, only find default, octagonal, ieq's.\n...\n1. a <= 10\n2. a - n <= 0\n3. -t <= -1\n4. -s <= -1\n5. -n + t <= 2\n6. -a <= 0\n\n\ntnguyen@debian ~/dig/src> sage -python -O dig.py ../tests/paper/Sqrt1.java -log 4 -noeqts -ideg 2 # find nonlinear octagonal inequalities\n...\n1. a*s - n*t <= 1\n2. a <= 10\n3. -t <= -1\n4. -s <= -1\n5. -n*t + s <= 1\n6. -n*s + t <= 1\n7. -n*s + a*t <= 0\n8. -n + t <= 2\n9. -a*n + t <= 2\n10. -a*n + s <= 3\n11. -a <= 0\n\ntnguyen@debian ~/dig/src> timeout 900 sage -python -O dig.py ../tests/paper/Sqrt1.java -log 4 -noeqts -icoefs 2 # find linear inequalities with coefs in {2,-1,0,1,2}\n...\n1. a <= 10\n2. 2*a - n <= 1\n3. -t <= -1\n4. -s <= -1\n5. -n + 2*t <= 6\n6. -a <= 0\n7. -2*n + t <= 1\n8. -2*n + s <= 2\n```\n\n---\n\n## Setup\n\nFirst, clone DIG\n\n```sh\ngit clone https://github.com/unsat/dig.git\n```\n\nThen go to DIG's directory (`cd dig`). Also make sure that you're in the right branch (e.g., `master` or `dev`).\nTo run DIG, you can either use the [provided *docker* script](#using-docker) (easiest way) or [install DIG yourself](#installing-dig).\n\n### Using DOCKER\n\n```sh\n# in DIG's directory\n\n# build the docker image,\n$ docker build . -t='dig'\n...\n...\n# this will take some time as it will build a Linux image with all necessary dependencies to run DIG. \n\n# then run dig\n$ docker run -it dig\n\n# docker will drop you into a Linux prompt like below.\n$ root@b53e0bd86c11:/dig/src#\n```\n\nYou are now ready to use DIG, see instructions in the [USAGE](#usage) section\n\n### Installing DIG\n\nYou can also install DIG yourself. The tool has been tested using the following setup:\n\n* Debian Linux 9 or 10 (64 bit)\n* SageMath `9.0` (64 bit)\n* Microsoft Z3 SMT solver `4.8.3`\n* Java JDK (Oracle `1.8.0_121` or OpenJDK `1.8.0_122`)\n* Java PathFinder and Symbolic Finder:\n * JPF (`java-8` branch, commit [`18a0c42de3e80be0c2ddcf0d212e376e576fcda0`](https://github.com/javapathfinder/jpf-core/commit/18a0c42de3e80be0c2ddcf0d212e376e576fcda0))\n * SPF (commit [`98a0e08fee323c15b651110dd3c28b2ce0c4e274`](https://github.com/SymbolicPathFinder/jpf-symbc/commit/98a0e08fee323c15b651110dd3c28b2ce0c4e274))\n\n#### Installing SAGE and Z3\n\n* Setup SAGE: download a precompiled [SageMath](http://mirrors.mit.edu/sage/linux/64bit/index.html) binary\n* Setup Z3: [download](https://github.com/Z3Prover/z3/releases) and build Z3 by following the instructions in its README file\n* To check that you have all needed stuff\n\n```sh\n# in DIG's src directory\n$ cd src\n$ sage helpers/check_requirements.py\n...\n...\nEverything seems OK. Have fun with DIG!\n```\n\n#### For Java files: install Java and Symbolic PathFinder\n\n* Install Java 8: either the JDK from Oracle 1.8.0_121 or the OpenJDK packaged in Debian (`apt-get install -y default-jdk`, besure the version is 1.8.0_121 or 1.8.0_122).\n\n* Install both Java PathFinder and the Symbolic Pathfinder extension\n\n```sh\n$ mkdir /PATH/TO/JPF\n$ cd /PATH/TO/JPF\n$ git clone https://github.com/javapathfinder/jpf-core #JPF\n$ git clone https://github.com/SymbolicPathFinder/jpf-symbc #Symbolic extension\n\n# build jpf\n$ cd jpf-core\n$ git checkout java-8 #switch to the java-8 branch\n$ ant\n\n#copy patched Listener file to SPF\n$ cp /PATH/TO/dig/src/java/InvariantListenerVu.java jpf-symbc/src/main/gov/nasa/jpf/symbc\n\n# build spf\n$ cd jpf-symbc\n$ ant\n\n# sometimes it helps to rebuild jpf-core again\n# cd jpf-core\n$ ant\n\n\n# Add the following to `~/.jpf/site.properties` (create `~/.jpf` if it doesn't exist)\njpf-core = /PATH/TO/JPF/jpf-core\njpf-symbc = /PATH/TO/JPF/jpf-symbc\nextensions=${jpf-core},${jpf-symbc}\n```\n\n* Compile Java files in `java` directory for instrumenting Java byte classes\n\n```sh\n# in DIG's src directory\n$ cd src/java\n$ make\n```\n\n#### For C files: install the [CIVL symbolic execution tool](https://vsl.cis.udel.edu/civl/)\n\n* Build CIL\n\n```sh\n# build CIL\n$ git clone https://github.com/cil-project/cil.git\n$ cd cil\n$ ./configure ; make\n```\n\n* Compile the Ocaml files in `ocaml` directory for instrumenting C files (to CIVL format)\n\n```sh\n# in DIG's src directory\n$ cd src/ocaml\n$ edit Makefile #point the OCAML_OPTIONS to where CIL is\n$ make\n```\n\n* Get CIVL\n\n```sh\n$ wget --no-check-certificate https://vsl.cis.udel.edu/lib/sw/civl/1.20/r5259/release/CIVL-1.20_5259.tgz\n$ tar xf CIVL-1.20_5259.tgz\n$ ln -sf CIVL-1.20_5259 civl\n$ ln -sf civl/lib/ lib\n\n\n# Tell CIVL to use Z3 by editing the ~/.sarl file\nprover {\n aliases = z3;\n kind = Z3;\n version = \"4.8.7 - 64 bit\";\n path = \"/home/SHARED/Devel/Z3/z3/z3\";\n timeout = 10.0;\n showQueries = false;\n showInconclusives = false;\n showErrors = true;\n}\n\n# test CIVL\n$ /home/SHARED/Devel/JAVA/jdk/bin/java -jar /home/SHARED/Devel/CIVL/lib/civl-1.20_5259.jar verify -maxdepth=20 $DIG/tests/tools/cohendiv_civl.c\nCIVL v1.20 of 2019-09-27 -- http://vsl.cis.udel.edu/civl\nvtrace1: q = 0; r = X_x; a = 0; b = 0; x = X_x; y = X_y\npath condition: (0<=(X_x-1))&&(0<=(X_y-1))\n...\n\n```\n\n#### Setup Paths\n\n* Put the following in your `~/.sh_profile`\n\n```sh\n# ~/.sh_profile\nexport Z3=PATH/TO/z3 #Z3 dir\nexport SAGE=PATH/TO/sage #where your SAGE dir is\nexport PYTHONPATH=$Z3/src/api/python:$PYTHONPATH\nexport JAVA_HOME=/PATH/TO/JAVA\nexport PATH=$SAGE:$JAVA_HOME/bin:$PATH\nexport JPF_HOME=/PATH/TO/JPF\nexport LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$JPF_HOME/jpf-symbc/lib/\n```\n\n* Some troubleshooting tips:\n * Make sure SAGE works, e.g., `sage` to run the SAGE interpreter or `sage --help`\n * Make sure Z3 is installed correctly so that you can do `sage -c \"import z3; z3.get_version()\"` without error.\n * Use DIG with `-log 4` to enable detail logging information, also look at the `settings.py` for various settings on where DIG looks for external programs such as `java` and `javac`\n\n---\n\n## Publications\n\nTechnical information about DIG can be found from these papers. The `SymInfer paper (ASE17)` is probably a good start.\n\n* Ton Chanh Le, Timos Antonopoulos, Parisa Fathololumi, Eric Koskinen, ThanhVu Nguyen. DynamiTe: Dynamic Termination and Non-termination Proofs. Proc. ACM Program. Lang. (OOPSLA), 2020\n* ThanhVu Nguyen, Didier Ishimwe, Alexey Malyshev, Timos Antonopoulos, and Quoc-Sang Phan. Using Dynamically Inferred Invariants to Analyze Program Runtime Complexity. Workshop on Software Security from Design to Deployment, 2020\n* ThanhVu Nguyen, Matthew Dwyer, and William Visser. SymInfer: Inferring Program Invariants using Symbolic States. In Automated Software Engineering (ASE). IEEE, 2017.\n* ThanhVu Nguyen, Timos Antopoulos, Andrew Ruef, and Michael Hicks. A Counterexample-guided Approach to Finding Numerical Invariants. In 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE), pages 605--615. ACM, 2017.\n* ThanhVu Nguyen, Deepak Kapur, Westley Weimer, and Stephanie Forrest. DIG: A Dynamic Invariant Generator for Polynomial and Array Invariants. Transactions on Software Engineering Methodology (TOSEM), 23(4):30:1--30:30, 2014.\n* ThanhVu Nguyen, Deepak Kapur, Westley Weimer, and Stephanie Forrest. Using Dynamic Analysis to Generate Disjunctive Invariants. In 36th International Conference on Software Engineering (ICSE), pages 608--619. IEEE, 2014.\n* ThanhVu Nguyen, Deepak Kapur, Westley Weimer, and Stephanie Forrest. Using Dynamic Analysis to Discover Polynomial and Array Invariants. In 34th International Conference on Software Engineering (ICSE), pages 683--693. IEEE, 2012. `Distinguish Paper award`\n\n## ACKNOWLEDGEMENTS\n\n* This project is supported in part by NSF grant CCF-1948536 and ARO grant W911NF-19-1-0054.\n","has_starred","hub_user","immutable_tags_settings",{"_71":11,"_72":73},"enabled","rules",[74],".*","is_automated","permissions",{"_78":17,"_79":11,"_80":11},"read","write","admin","user","storage_size",5991662860,"orgData","recentTags",[87,124],{"_88":40,"_89":90,"_91":92,"_93":94,"_95":96,"_46":113,"_114":90,"_115":29,"_116":52,"_53":117,"_118":119,"_120":104,"_121":113,"_122":62,"_123":17},"content_type","creator",12365161,"full_size",2033789528,"id",143284418,"images",[97],{"_98":99,"_100":101,"_102":44,"_103":104,"_105":106,"_107":108,"_109":44,"_110":-5,"_111":92,"_59":62,"_112":-5},"architecture","amd64","digest","sha256:ad47b24ac1406897e8199a38465abb3371f48a00e7e5fe31f225ebabd747459f","features","last_pulled","2026-09-29T06:12:31.869173383Z","last_pushed","2021-03-28T07:43:35Z","os","linux","os_features","os_version","size","variant","2021-03-28T07:43:34.514619Z","last_updater","last_updater_username","media_type","latest","repository",11979333,"tag_last_pulled","tag_last_pushed","tag_status","v2",{"_88":40,"_89":90,"_91":125,"_93":126,"_95":127,"_46":132,"_114":90,"_115":29,"_116":52,"_53":133,"_118":119,"_120":130,"_121":132,"_122":62,"_123":17},2033771693,143285097,[128],{"_98":99,"_100":129,"_102":44,"_103":130,"_105":131,"_107":108,"_109":44,"_110":-5,"_111":125,"_59":62,"_112":-5},"sha256:0bfea28303224bfc09b70f8ddd3c4a22ca39eeea224d7674a8a76ba1c0a7629a","2026-09-29T06:12:29.603471245Z","2021-03-28T07:20:59Z","2021-03-28T07:20:58.120456Z","1.0.1","sbxKitMetadata","isPotentialSpam","isHubSbxKitsEnabled","showSbxLogoOverride","sbxTrademarkText","displaySecurityMetadata","tagAttestations","tagsHaveAttestations",[],"routes/_layout.r.$namespace.$reponame.tags",{"_34":145,"_152":153,"_141":166,"_167":11},{"_36":146,"_38":147,"_41":42,"_43":44,"_45":11,"_46":47,"_48":49,"_50":148,"_53":31,"_28":29,"_54":55,"_56":40,"_57":58,"_59":60,"_61":62,"_63":-5,"_64":58,"_65":66,"_67":11,"_68":29,"_69":149,"_75":11,"_76":151,"_81":29,"_82":83},[],[40],[52],{"_71":11,"_72":150},[74],{"_78":17,"_79":11,"_80":11},"tags",{"_154":155,"_156":-5,"_157":-5,"_158":159},"count",2,"next","previous","results",[160,163],{"_88":40,"_89":90,"_91":92,"_93":94,"_95":161,"_46":113,"_114":90,"_115":29,"_116":52,"_53":117,"_118":119,"_120":104,"_121":113,"_122":62,"_123":17},[162],{"_98":99,"_100":101,"_102":44,"_103":104,"_105":106,"_107":108,"_109":44,"_110":-5,"_111":92,"_59":62,"_112":-5},{"_88":40,"_89":90,"_91":125,"_93":126,"_95":164,"_46":132,"_114":90,"_115":29,"_116":52,"_53":133,"_118":119,"_120":130,"_121":132,"_122":62,"_123":17},[165],{"_98":99,"_100":129,"_102":44,"_103":130,"_105":131,"_107":108,"_109":44,"_110":-5,"_111":125,"_59":62,"_112":-5},[],"canDeleteTags","actionData","errors"]

abueide/dig

Tags for abueide/dig