select
    /*+ gather_plan_statistics */
    t1.id,
    t1.n1,
    t1.v1,
    t2.column_value n1
from
    t1,
    table (
        (
        select
            collect(t2.n1)
        from
            t2
        where
            t1.colx in (7, 11, 13)
        and t2.id = t1.n1
        )
    )(+) t2
where
    t1.id = 15
;

This approach has the same issues as Timur’s one (shown above).
PS. Sorry, but I can’t figure out how to format code in your blog.

alter table t1 add colx number;
update t1 set colx = n1;
commit;

When select statement is written like this

select
    t1.id,
    t1.n1,
    t1.v1,
    t2.n1
from
    t1
,
    t2
where
    t1.id = 15
and t2.id(+) = t1.n1
and T1.COLX in (7, 11, 13)

then Oracle treats “T1.COLX in (7, 11, 13)” as post-join predicate and we don’t achieve desirable recordset.

So the main point is: write condition “T1.COLX in (7, 11, 13)” so that Oracle treats it as pre-join predicate:

SQL> select
  2      t1.id,
  3      t1.n1,
  4      t1.v1,
  5      t2.n1
  6  from
  7      t1
  8  ,
  9      t2
 10  where
 11      t1.id = 15
 12  and t2.id(+) = t1.n1
 13  and decode(T1.COLX,7,0,11,0,13,0)=nvl2(t2.id(+),0,0);

        ID         N1 V1                 N1
---------- ---------- ---------- ----------
        15         15 0000000015

SQL> select * from table(dbms_xplan.display_cursor(null,null,'ALLSTATS LAST'));

PLAN_TABLE_OUTPUT
------------------------------------------------------------------------------------------------------------------------------------------------------
SQL_ID  du7ky61ubqxxv, child number 0
-------------------------------------
select     t1.id,     t1.n1,     t1.v1,     t2.n1 from     t1 ,     t2
where     t1.id = 15 and t2.id(+) = t1.n1 and
decode(T1.COLX,7,0,11,0,13,0)=nvl2(t2.id(+),0,0)

Plan hash value: 3024481811

------------------------------------------------------------------------------------------------
| Id  | Operation                    | Name  | Starts | E-Rows | A-Rows |   A-Time   | Buffers |
------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT             |       |      1 |        |      1 |00:00:00.01 |       6 |
|   1 |  NESTED LOOPS OUTER          |       |      1 |      1 |      1 |00:00:00.01 |       6 |
|   2 |   TABLE ACCESS BY INDEX ROWID| T1    |      1 |      1 |      1 |00:00:00.01 |       4 |
|*  3 |    INDEX RANGE SCAN          | T1_I1 |      1 |      1 |      1 |00:00:00.01 |       3 |
|   4 |   TABLE ACCESS BY INDEX ROWID| T2    |      1 |      1 |      0 |00:00:00.01 |       2 |
|*  5 |    INDEX RANGE SCAN          | T2_I1 |      1 |      1 |      0 |00:00:00.01 |       2 |
------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   3 - access("T1"."ID"=15)
   5 - access("T2"."ID"="T1"."N1")
       filter(DECODE("T1"."COLX",7,0,11,0,13,0)=NVL2("T2"."ID",0,0))


26 rows selected.

Of course, the plan is little bit different than yours with “T1.COLX in (7, 11, 13)” condition. But we can see both filter and access predicates. :-)

Essentially the optimizer will transform almost any SQL to suit its purposes; ANSI is only slightly special in this respect; but you are right that in effect Oracle transforms from ANSI style to Oracle style before optimising in most cases. As far as I know there are only two classes of ANSI SQL that have a “native optimization” code path – the full outer join and the partitioned outer join.