Re: ptx kernels? proprietary assembly? relation to KR

Paola, all,

Thanks for the clarification. I think part of the friction here is that 
we’re talking about different layers at once, so let me separate them 
explicitly.

At the KR level, I fully agree this CG is dealing with the “highest 
level conceptual abstraction” in computer science: concepts, terms, 
domains of discourse, adequacy. That’s where K3D’s 
Houses/Rooms/Nodes/Doors/Galaxy/Tablet vocabulary lives. It’s also where 
StratML, Dave’s “technical argot,” and Milton’s domains of discourse 
sit. That is the only layer I am proposing as a contribution to AI‑KR.

At the implementation level, those abstractions have to run somewhere. 
In the web stack, HTML/CSS/JS are the open specs; browsers (Chrome, 
Safari, Edge, Firefox) are proprietary or mixed implementations that 
interpret them. No one would say that because Firefox is mostly C++ or 
Chrome has proprietary code, HTML is “at the opposite end of the 
spectrum from KR” or out of scope for W3C.

PTX is in that same implementation category: it’s one documented ISA 
that I happen to use to implement KR operations (embeddings, spatial 
layouts, consolidation) on NVIDIA GPUs. The code I write on top of PTX 
(K3D’s kernels, bridges, and tests) is open‑source; the KR vocabulary 
and structures I’ve been talking about are substrate‑agnostic. They 
could in principle run on other GPU backends or CPU implementations 
without changing the semantics.

So, to answer your questions directly:

How does this relate to open web standards in AI?
The KR contribution is at the standards layer: spatial vocabularies, 
domains of discourse, and methods that could be expressed in 
RDF/JSON‑LD/glTF extensions, independent of PTX. PTX is just one way of 
implementing those semantics efficiently on current hardware.

How does it relate to KR concepts/terms for knowledge domains?
The terms I’ve proposed (House, Room, Node, Door, Galaxy, Tablet) are 
exactly that: KR concepts for spatial domains of discourse, which can be 
linked to existing upper/domain ontologies and vocabularies. They’re not 
PTX terms.

How does it fit in scoping the KR domain?
By treating “domain boundary” (House), “sub‑domain” (Room), “atomic 
concept” (Node) and “links” (Doors, Galaxy neighborhoods) as first‑class 
KR primitives, with explicit adequacy assumptions, not as implementation 
details. That’s very much in line with the domains‑of‑discourse 
discussion Dave and Milton have started.

If implementation details in PTX or CUDA are outside your sphere of 
interest, that’s fine; I’m not asking the CG to standardize those. What 
I am proposing, and where I think there is genuine overlap with this 
group’s mission, is the KR layer above that: how we name, structure and 
relate the domains of discourse we can actually model, under the 
adequacy and resource limits Milton and Dave have been talking about.

Best regards,
Daniel

On 11/14/25 3:01 AM, Paola Di Maio wrote:
> Please be reminded that KR domain points to the highest and most level 
> conceptual abstraction
> in computer science.
>
> It is at the opposite end of the spectrum in relation to assembly code
>
> For the rest of us: looks like what Daniel is pointing us to is a 
> proprietary technology, assembly language
>
> Question: how does it relate to open web standards in AI?
> how does this relate do KR *concepts and terms for knowledge domains
> how does it fit in the scoping of defining the KR domain?
> discuss
>
> Personally, this is outside my sphere of competence and interest, KR 
> is at the opposite end
> Possibly also outside the IP  boundary *NVIDIA proprietary code
>
> PDM
>
> The term
> *PTX kernel* i refers to a high-performance *GPU kernel explicitly 
> programmed in NVIDIA's Parallel Thread Execution (PTX) assembly 
> language* to optimize specific operations within KRL models, such as 
> those used in large language models (LLMs).
> PTX: An Intermediate Language for GPUs
> PTX is a low-level, human-readable, assembly-like intermediate 
> representation (IR) or virtual machine instruction set architecture 
> (ISA) for NVIDIA GPUs. It acts as a stable layer between high-level 
> programming languages (like CUDA C/C++, PyTorch, or Triton) and the 
> proprietary, architecture-specific machine code (SASS).
>
>   * *Compilation Flow*: High-level CUDA code is first compiled into
>     PTX. The NVIDIA driver then just-in-time (JIT) compiles the PTX
>     into the specific SASS machine code for the target GPU
>     architecture at runtime.
>   * *Purpose*: This JIT compilation enables forward compatibility,
>     allowing a single application binary to run on future GPU hardware
>     that didn't exist when the program was compiled.
>
> Role in Knowledge Representation Learning and AI
> In modern AI and KRL, especially with the demanding workloads of large 
> models, performance optimization is critical. While most developers 
> write high-level code, some use PTX for extreme, hardware-specific 
> optimizations.
>
>   * *Manual Optimization*: Manually writing or modifying PTX code
>     allows experts to leverage specific, cutting-edge hardware
>     features (e.g., in Flash Attention implementations) that may not
>     yet be exposed through higher-level programming interfaces or
>     automatically utilized by compilers.
>   * *Research and Analysis*: Researchers use PTX as the nearest
>     documented layer to the actual machine code to analyze and
>     optimize GPU performance, memory access, and power consumption for
>     AI inference.
>   * *AI for Kernels*: The field is seeing the emergence of using large
>     language models (LMs) to generate and optimize efficient GPU
>     kernels, sometimes working with PTX or SASS directly, to push
>     performance beyond what is achievable with standard compilers alone.
>
>  *
>
>
> In summary, a *PTX kernel* is a GPU program at the assembly level, 
> providing a means for low-level control and advanced optimization 
> crucial for high-performance computing in KRL applications.
>