# Abstract Representation

### What

Abstract representation of a problem involves distilling the essential features and relationships to understand its core structure, often removing unnecessary details. This representation simplifies the problem into a form that is easier to analyze, model, or solve programmatically.

### When

Abstract representation is useful when:

- A problem is too complex to be understood or solved in its entirety.
- You need to generalize the problem for broader applicability.
- You aim to identify patterns or relationships that are not immediately obvious.

### Where

Abstract representation can be applied in various domains such as:

- Computer Science: Algorithms, data structures, and system designs.
- Mathematics: Models and equations.
- Business: Strategic planning and system optimization.
- Engineering: Designs and simulations.

### How to Apply

- Identify the problem’s key elements and relationships.
- Eliminate extraneous details that don’t contribute to solving the problem.
- Create a model or framework that encapsulates the essence of the problem.
- Use this model to approach the problem in a more focused way.

### Examples

- In a graph problem like “finding the shortest path,” the abstract representation is the graph itself, with nodes representing locations and edges representing paths.
- In business, a SWOT analysis abstracts a company’s situation into Strengths, Weaknesses, Opportunities, and Threats.
- In a sorting algorithm, the abstract representation is an array or list of elements with certain rules for their ordering.

### Diagrams

Consider a simple graph with nodes and edges to represent a network problem. Or imagine a flowchart that starts with a real-world problem at the top and breaks it down into abstracted components that are easier to handle. These would serve as diagrams for an abstract representation.

Existing knowledge can become an impediment to solving a given problem. Combination Sum III is a good example.

## Abstract Representation of the Problem

Let’s formulate an abstract representation of this problem:

We have a pool of unique objects, each assigned with a certain positive number. There is also a designated sum total we aim to achieve. The challenge lies in identifying how many unique ways we can pick objects (repeating the same object is permitted) from our pool so that the sum of their assigned numbers equals the designated sum. The sequence of picking matters – even when the same objects are chosen, differing sequences are considered unique.

Here, the pool of objects corresponds to our array of numbers (`nums`

), the assigned positive number of each object is the integer value itself, and the designated sum is the `target`

. We are searching for different ways of picking these objects (where picking the same object multiple times is possible) such that the sum of the objects’ numbers is equal to the `target`

.

This general representation removes specific details about numbers, arrays, and targets, and instead highlights the main structure of the problem and the principal task: identifying the number of ways to pick objects from a pool to total up to a designated sum, where sequence matters and repetition is possible.

By formulating our own general representation, we steer clear of ambiguous terms and express our understanding of the problem.

## Dealing with Confusing Term

In many mathematical contexts, a combination refers to a selection of items where the order of the items does not matter. This means that [1,1,2] and [2,1,1] would be considered the same combination.

However, in some computational contexts (like in this problem), the term combination may refer to a multi-set, where the order does matter, and [1,1,2] and [2,1,1] would indeed be considered two different combinations.

This may seem a bit confusing, but it’s an example of how the same term can have slightly different interpretations in different fields or contexts. The key thing is to understand how the term is being used in the context of the specific problem you’re working on.

For the problem you’re dealing with, when we say ‘combination’, we mean a sequence of numbers that add up to a target number, where the order of the numbers in the sequence does matter. So, [1,1,2] and [2,1,1] are counted as separate combinations. This is a somewhat looser usage of the term ‘combination’ than you might see in a strict mathematical context.

This is why it’s important to read and understand the problem statement carefully - to make sure you understand the definitions and constraints it’s using.

- Check Oxford TRIZ and summarize the concept here.

## Abstract Representation and Abstraction

Abstraction and abstract representation are closely related concepts, often used interchangeably in some contexts. However, they serve different roles in the problem-solving process.

### Abstraction

Abstraction is a cognitive process that involves identifying the essential characteristics or patterns in a complex situation, while ignoring the less relevant details. It helps to simplify the problem by focusing on what’s most important.

### Abstract Representation

Abstract representation is the result or outcome of applying abstraction to a problem. After abstracting the key elements, these elements are put into a model, algorithm, or some other form that represents the essence of the problem.

### Relationship

Abstraction is the mental activity you engage in to distill the critical features of a problem. The abstract representation is what you end up with after applying this process: a simplified model or structure that encapsulates these critical features. In essence, the abstract representation serves as a concrete (though simplified) expression of the abstract thinking you’ve applied to a problem.

So, abstraction provides the method or approach, and the abstract representation is the end result that encapsulates the core aspects of the problem you’re solving.

Abstract representation and abstraction are closely related concepts, often used in tandem for problem-solving in computer science and software engineering.

**Abstraction**: This is the process of simplifying complex reality by modeling only the relevant parts. In software development, abstraction often involves hiding details to present a simplified model of what’s important for the problem at hand.**Abstract Representation**: This is the outcome or product of applying the process of abstraction. You take a problem, remove all the unnecessary details, and are left with a simplified model, i.e., the abstract representation. This representation usually contains only the elements that are necessary to understand and solve the problem.

### Relationship

**Foundation for Representation**: Abstraction serves as the method by which you identify which elements of a problem are crucial and which are not. This discernment allows you to create an abstract representation that captures the essence of the problem.**Facilitates Problem-Solving**: The abstract representation, being a simplified model, makes it easier to devise algorithms and solutions. It cuts through the complexity, allowing you to focus on core mechanics.**Iterative Process**: Abstraction can be an iterative process. You might start with a basic abstract representation and refine it as you delve deeper into the problem, iterating between abstraction (the process) and your abstract representation (the model) to arrive at an optimal solution.**Reusable Components**: Both concepts aim for reusability. Once an abstract representation is defined for a specific problem, it can often be reused or adapted for similar problems. The process of abstraction that led to this representation can also be applied to other domains.**Cognitive Function**: Abstraction allows human cognition to tackle complex problems by reducing them to their essentials. The abstract representation serves as a cognitive model that aids in understanding and solving the problem.**Optimization and Efficiency**: An abstract representation, by focusing only on essential aspects, often leads to more efficient problem-solving strategies, algorithms, or solutions.

In summary, abstraction is the process, and abstract representation is the result. Together, they play a critical role in effective problem-solving, especially in fields like software engineering where complexity is a given.