How to define an interface with properties?

I have a question: is it possible to set an interface for a linear space?

Let me remind you that in linear space L there is an operation of adding elements and multiplying an element by a number. Moreover, two properties are fulfilled:

1)a+b in L

2)ak in L, where k - scalar

I presented the interface for linear space in the following form:

type Point interface {
}

type LinSpace interface {
    Sum(x, y Point)
    Prod(x Point, k float64)
}

how can i account for the above two properties in the interface definition?

Interfaces can contain only methods.

You can do something like this:

    // Effective Go says: interface names should contain prefix -er 
    type LinSpacer interface {
        Sum() float64
        Prod(k float64) float64
    }
    
    // Struct that implements interface
    type LinSpaceImpl struct {
    	A float64
        B float64
    }
    
    // Implementation of Sum() method
    // Also, You don't need to pass A and B vars
    // because they're already exist in LinSpaceImpl
    func (l *LinSpaceImpl) Sum() float64 {
        return l.A + l.B
    }
    
    // Implementation of Prod() method
    // Unlike the Sum() method, here we need extra param - k
    // So it has to be passed, or You can add it to
    // LinSpaceImpl as another fields but it doesn't
    // make any sense though
    func (l *LinSpaceImpl) Prod(k float64) float64 {
        return l.A * k
    }
    
    // Unnecessary "constructor" to optimize Your main function
    // And clarify code
    func NewLinSpace(a, b float64) LinSpacer {
    // Since LinSpaceImpl correctly implements LinSpacer interface
    // You can return instance of LinSpaceImpl as LinSpacer
        return &LinSpaceImpl{
    		A: a,
    		B: b,
    	}
    }

And then you can do this in your main (or other) function:

    // Use any float values
    ls := NewLinSpace(11.2, 24.7)
    
    fmt.Println(ls.Sum())      // 35.9
    fmt.Println(ls.Prod(30.2)) // 338.23999999999995

This is how "OOP" works in Go.