Property Domains for Adjective Dimensions

@cite{giles-etal-2026} @cite{wolfe-horowitz-2017}

Structured replacement for raw String dimension labels in adjective entries. Connects adjective semantics to the perceptual noise infrastructure in RSA.Core.Noise via PropertyDomain.noiseDiscrimination.

Design

A Dimension pairs a human-readable name with a PropertyDomain that classifies the perceptual channel. Smart constructors cover all dimensions used across the English adjective fragments.

Perceptual Grounding

The first four domains (color, size, material, orientation) have established relationships to perceptual discriminability:

• Colour and orientation are privileged features in visual search (@cite{wolfe-horowitz-2017}): they guide pre-attentive filtering and produce pop-out effects.
• Size is privileged but weaker than colour/orientation.
• Material is not visually privileged; its perception often requires auditory or haptic verification (@cite{giles-etal-2026}).

inductive Core.PropertyDomain : Type

Broad perceptual/cognitive domain that a gradable dimension belongs to. The first four (color, size, material, orientation) have established noise parameters in RSA.Noise; the rest are classified but not yet parameterised.

• color : PropertyDomain
• size : PropertyDomain
• material : PropertyDomain
• orientation : PropertyDomain
• sensory : PropertyDomain
• evaluative : PropertyDomain
• psychological : PropertyDomain
• state : PropertyDomain

def Core.instReprPropertyDomain.repr : PropertyDomain → Nat → Std.Format

Equations

• One or more equations did not get rendered due to their size.
• Core.instReprPropertyDomain.repr Core.PropertyDomain.color prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Core.PropertyDomain.color")).group prec✝
• Core.instReprPropertyDomain.repr Core.PropertyDomain.size prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Core.PropertyDomain.size")).group prec✝
• Core.instReprPropertyDomain.repr Core.PropertyDomain.state prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Core.PropertyDomain.state")).group prec✝

instance Core.instReprPropertyDomain : Repr PropertyDomain

Equations

• Core.instReprPropertyDomain = { reprPrec := Core.instReprPropertyDomain.repr }

instance Core.instDecidableEqPropertyDomain : DecidableEq PropertyDomain

Equations

• Core.instDecidableEqPropertyDomain x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

instance Core.instBEqPropertyDomain : BEq PropertyDomain

Equations

• Core.instBEqPropertyDomain = { beq := Core.instBEqPropertyDomain.beq }

def Core.instBEqPropertyDomain.beq : PropertyDomain → PropertyDomain → Bool

Equations

• Core.instBEqPropertyDomain.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

instance Core.instInhabitedPropertyDomain : Inhabited PropertyDomain

Equations

• Core.instInhabitedPropertyDomain = { default := Core.instInhabitedPropertyDomain.default }

def Core.instInhabitedPropertyDomain.default : PropertyDomain

Equations

• Core.instInhabitedPropertyDomain.default = Core.PropertyDomain.color

structure Core.Dimension : Type

A named dimension classified by its perceptual domain.

• name : String
• domain : PropertyDomain

instance Core.instReprDimension : Repr Dimension

Equations

• Core.instReprDimension = { reprPrec := Core.instReprDimension.repr }

def Core.instReprDimension.repr : Dimension → Nat → Std.Format

Equations

• One or more equations did not get rendered due to their size.

instance Core.instBEqDimension : BEq Dimension

Equations

• Core.instBEqDimension = { beq := fun (d1 d2 : Core.Dimension) => d1.name == d2.name && d1.domain == d2.domain }

instance Core.instDecidableEqDimension : DecidableEq Dimension

Equations

• Core.instDecidableEqDimension d1 d2 = if h1 : d1.name = d2.name then if h2 : d1.domain = d2.domain then isTrue ⋯ else isFalse ⋯ else isFalse ⋯

instance Core.instInhabitedDimension : Inhabited Dimension

Equations

• Core.instInhabitedDimension = { default := { name := "", domain := Core.PropertyDomain.state } }

inductive Core.NegationType : Type

Types of antonymy for gradable adjective pairs.

Contradictories (e.g., "clean" / "dirty"):

• Cannot both be true AND cannot both be false
• Negation of one entails the other: not clean ⟹ dirty
• No extension gap between the two standards

Contraries (e.g., "tall" / "short", "large" / "small"):

• Cannot both be true BUT can both be false
• Negation of one does NOT entail the other: not large ⟹/⟹ small
• Extension gap between the two standards

References:

• @cite{cruse-1986}. Lexical Semantics.
• @cite{horn-1989}. A Natural History of Negation.
• @cite{kennedy-2007}. Vagueness and Grammar.

• contradictory : NegationType
• contrary : NegationType

instance Core.instReprNegationType : Repr NegationType

Equations

• Core.instReprNegationType = { reprPrec := Core.instReprNegationType.repr }

def Core.instReprNegationType.repr : NegationType → Nat → Std.Format

Equations

• One or more equations did not get rendered due to their size.
• Core.instReprNegationType.repr Core.NegationType.contrary prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Core.NegationType.contrary")).group prec✝

instance Core.instDecidableEqNegationType : DecidableEq NegationType

Equations

• Core.instDecidableEqNegationType x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Core.instBEqNegationType.beq : NegationType → NegationType → Bool

Equations

• Core.instBEqNegationType.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

instance Core.instBEqNegationType : BEq NegationType

Equations

• Core.instBEqNegationType = { beq := Core.instBEqNegationType.beq }

def Core.Dimension.height : Dimension

Equations

• Core.Dimension.height = { name := "height", domain := Core.PropertyDomain.size }

def Core.Dimension.width : Dimension

Equations

• Core.Dimension.width = { name := "width", domain := Core.PropertyDomain.size }

def Core.Dimension.length : Dimension

Equations

• Core.Dimension.length = { name := "length", domain := Core.PropertyDomain.size }

def Core.Dimension.temperature : Dimension

Equations

• Core.Dimension.temperature = { name := "temperature", domain := Core.PropertyDomain.sensory }

def Core.Dimension.happiness : Dimension

Equations

• Core.Dimension.happiness = { name := "happiness", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.cost : Dimension

Equations

• Core.Dimension.cost = { name := "cost", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.price : Dimension

Equations

• Core.Dimension.price = { name := "price", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.quality : Dimension

Equations

• Core.Dimension.quality = { name := "quality", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.value : Dimension

Equations

• Core.Dimension.value = { name := "value", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.intelligence : Dimension

Equations

• Core.Dimension.intelligence = { name := "intelligence", domain := Core.PropertyDomain.psychological }

def Core.Dimension.fullness : Dimension

Equations

• Core.Dimension.fullness = { name := "fullness", domain := Core.PropertyDomain.state }

def Core.Dimension.wetness : Dimension

Equations

• Core.Dimension.wetness = { name := "wetness", domain := Core.PropertyDomain.state }

def Core.Dimension.cleanliness : Dimension

Equations

• Core.Dimension.cleanliness = { name := "cleanliness", domain := Core.PropertyDomain.state }

def Core.Dimension.straightness : Dimension

Equations

• Core.Dimension.straightness = { name := "straightness", domain := Core.PropertyDomain.state }

def Core.Dimension.flatness : Dimension

Equations

• Core.Dimension.flatness = { name := "flatness", domain := Core.PropertyDomain.state }

def Core.Dimension.openness : Dimension

Equations

• Core.Dimension.openness = { name := "openness", domain := Core.PropertyDomain.state }

def Core.Dimension.freedom : Dimension

Equations

• Core.Dimension.freedom = { name := "freedom", domain := Core.PropertyDomain.state }

def Core.Dimension.tightness : Dimension

Equations

• Core.Dimension.tightness = { name := "tightness", domain := Core.PropertyDomain.state }

def Core.Dimension.alive : Dimension

Equations

• Core.Dimension.alive = { name := "alive", domain := Core.PropertyDomain.state }

def Core.Dimension.pregnancy : Dimension

Equations

• Core.Dimension.pregnancy = { name := "pregnancy", domain := Core.PropertyDomain.state }

def Core.Dimension.hardness : Dimension

Equations

• Core.Dimension.hardness = { name := "hardness", domain := Core.PropertyDomain.state }

def Core.Dimension.smoothness : Dimension

Equations

• Core.Dimension.smoothness = { name := "smoothness", domain := Core.PropertyDomain.state }

def Core.Dimension.purity : Dimension

Equations

• Core.Dimension.purity = { name := "purity", domain := Core.PropertyDomain.state }

def Core.Dimension.cracking : Dimension

Equations

• Core.Dimension.cracking = { name := "cracking", domain := Core.PropertyDomain.state }

def Core.Dimension.denting : Dimension

Equations

• Core.Dimension.denting = { name := "denting", domain := Core.PropertyDomain.state }

def Core.Dimension.scratching : Dimension

Equations

• Core.Dimension.scratching = { name := "scratching", domain := Core.PropertyDomain.state }

def Core.Dimension.shattering : Dimension

Equations

• Core.Dimension.shattering = { name := "shattering", domain := Core.PropertyDomain.state }

def Core.Dimension.weight : Dimension

Equations

• Core.Dimension.weight = { name := "weight", domain := Core.PropertyDomain.size }

def Core.Dimension.thickness : Dimension

Equations

• Core.Dimension.thickness = { name := "thickness", domain := Core.PropertyDomain.size }

def Core.Dimension.depth : Dimension

Equations

• Core.Dimension.depth = { name := "depth", domain := Core.PropertyDomain.size }

def Core.Dimension.speed : Dimension

Equations

• Core.Dimension.speed = { name := "speed", domain := Core.PropertyDomain.size }

def Core.Dimension.strength : Dimension

Equations

• Core.Dimension.strength = { name := "strength", domain := Core.PropertyDomain.size }

def Core.Dimension.age : Dimension

Equations

• Core.Dimension.age = { name := "age", domain := Core.PropertyDomain.size }

def Core.Dimension.brightness : Dimension

Equations

• Core.Dimension.brightness = { name := "brightness", domain := Core.PropertyDomain.sensory }

def Core.Dimension.volume : Dimension

Equations

• Core.Dimension.volume = { name := "volume", domain := Core.PropertyDomain.sensory }

def Core.Dimension.danger : Dimension

Equations

• Core.Dimension.danger = { name := "danger", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.beauty : Dimension

Equations

• Core.Dimension.beauty = { name := "beauty", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.importance : Dimension

Equations

• Core.Dimension.importance = { name := "importance", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.safety : Dimension

Equations

• Core.Dimension.safety = { name := "safety", domain := Core.PropertyDomain.evaluative }

def Core.Dimension.generalSize : Dimension

Equations

• Core.Dimension.generalSize = { name := "size", domain := Core.PropertyDomain.size }

def Core.Dimension.color : Dimension

Equations

• Core.Dimension.color = { name := "color", domain := Core.PropertyDomain.color }

def Core.Dimension.material : Dimension

Equations

• Core.Dimension.material = { name := "material", domain := Core.PropertyDomain.material }

def Core.Dimension.orientation : Dimension

Equations

• Core.Dimension.orientation = { name := "orientation", domain := Core.PropertyDomain.orientation }

def Core.PropertyDomain.requiresComparisonClass : PropertyDomain → Bool

Whether adjectives in this domain typically require comparison-class computation for interpretation. Size, evaluative, psychological, and sensory domains contain relative gradable adjectives (RGAs) interpreted relative to a contextually-determined standard. Color, material, orientation, and state domains contain adjectives with more stable meanings.

This distinction is theoretically significant: @cite{sedivy-etal-1999} showed that comparison-class-dependent (scalar) adjectives trigger contrastive inferences in referential contexts, while non-dependent (color) adjectives do not.

Equations

• Core.PropertyDomain.size.requiresComparisonClass = true
• Core.PropertyDomain.evaluative.requiresComparisonClass = true
• Core.PropertyDomain.psychological.requiresComparisonClass = true
• Core.PropertyDomain.sensory.requiresComparisonClass = true
• Core.PropertyDomain.color.requiresComparisonClass = false
• Core.PropertyDomain.material.requiresComparisonClass = false
• Core.PropertyDomain.orientation.requiresComparisonClass = false
• Core.PropertyDomain.state.requiresComparisonClass = false