## Code Snippet: Theorem Definitions ### Overview The image displays a code snippet, likely from a formal verification system like Lean or Coq, defining three theorems related to measure theory and real numbers. The code uses a functional programming style with dependent types. ### Components/Axes * **Header:** Contains three colored circles (red, yellow, green) in the top-left corner, likely for window management. * **Main Content:** The code snippet itself, consisting of three theorem definitions. ### Detailed Analysis or ### Content Details **Theorem 1: `ite_pull_measureOf`** * **Name:** `ite_pull_measureOf` * **Type Parameters:** `X` (presumably a type representing a set) * **Context:** * `[MeasurableSpace X]` (X is a measurable space) * `(c : Prop)` (c is a proposition) * `[Decidable c]` (c is decidable) * `(μ ν : Measure X)` (μ and ν are measures on X) * `(A : Set X)` (A is a set in X) * **Statement:** `(if c then μ else v) A = (if c then μ A else v A) := by split_ifs <;> rfl` * This theorem states that applying the conditional measure (if c then μ else v) to a set A is equivalent to applying the measures μ and ν to A conditionally and then combining the results. * `:= by split_ifs <;> rfl` indicates that the proof is done by splitting cases based on the condition `c` and then using reflexivity (`rfl`). **Theorem 2: `Measure.prod_volume`** * **Name:** `Measure.prod_volume` * **Type Parameters:** `X Y` * **Context:** * `[MeasureSpace X]` (X is a measure space) * `[MeasureSpace Y]` (Y is a measure space) * **Statement:** `(Measure.prod (volume : Measure X) (volume : Measure Y)) = volume := by rfl` * This theorem states that the product of the volumes (measures) on measure spaces X and Y is equal to the volume. * `:= by rfl` indicates that the proof is done by reflexivity. **Theorem 3: `ite_pull_ennreal_toReal`** * **Name:** `ite_pull_ennreal_toReal` * **Context:** * `(c : Prop)` (c is a proposition) * `[Decidable c]` (c is decidable) * `(x y : ENNReal)` (x and y are extended non-negative real numbers) * **Statement:** `(if c then x else y).toReal = (if c then x.toReal else y.toReal) := by split_ifs <;> rfl` * This theorem states that converting a conditional extended non-negative real number (if c then x else y) to a real number is equivalent to converting x and y to real numbers conditionally and then combining the results. * `:= by split_ifs <;> rfl` indicates that the proof is done by splitting cases based on the condition `c` and then using reflexivity. ### Key Observations * All three theorems involve conditional expressions (`if c then ... else ...`). * All three theorems are proven by splitting cases based on the condition `c` and then using reflexivity. * The theorems relate to measure theory and real numbers, suggesting a focus on formal verification in these areas. ### Interpretation The code snippet demonstrates the use of a formal verification system to define and prove theorems in measure theory and real analysis. The theorems are relatively simple, but they illustrate the basic principles of conditional reasoning and the use of reflexivity for proving equalities. The use of dependent types allows for precise specification of the types of objects involved, which is crucial for formal verification. The theorems likely form part of a larger library of verified mathematical results.

\n ## Code Snippet: Mathematical Theorems ### Overview The image displays a code snippet, likely from a formal proof assistant system (such as Lean or Coq), containing three mathematical theorems. The code is presented in a monospaced font against a dark background. The theorems involve concepts from measure theory and real analysis. ### Components/Axes There are no axes or traditional chart components. The content consists entirely of text-based code. The code is structured into three distinct theorem definitions, each separated by a blank line. Each theorem definition includes: * `theorem` keyword * Theorem name (e.g., `ite_pull_measure0f`) * Type signature with arguments enclosed in square brackets (e.g., `{X} [MeasurableSpace X] (c : Prop) [Decidable c]`) * Theorem body, defining the relationship between variables and functions. * `:= by` followed by a proof tactic (e.g., `split_ifs <>; rfl`) ### Detailed Analysis or Content Details **Theorem 1: `ite_pull_measure0f`** ``` theorem ite_pull_measure0f {X} [MeasurableSpace X] (c : Prop) [Decidable c] (μ v : Measure X) (A : Set X) : (if c then μ else v) A = (if c then μ A else v A) := by split_ifs <>; rfl ``` * **Arguments:** * `{X}`: A type variable representing a set. * `[MeasurableSpace X]`: A typeclass instance indicating that `X` is a measurable space. * `(c : Prop)`: A proposition `c`. * `[Decidable c]`: A typeclass instance indicating that `c` is decidable (i.e., we can determine whether it is true or false). * `(μ v : Measure X)`: Two measures, `μ` and `v`, defined on the measurable space `X`. * `(A : Set X)`: A measurable set `A` within the measurable space `X`. * **Statement:** The theorem states that applying the conditional measure `(if c then μ else v)` to the set `A` is equivalent to applying the conditional measure to `A` individually for each measure `μ` and `v`. * **Proof:** The proof uses the `split_ifs` tactic to split the goal into cases based on the truth value of `c`, and then uses the `rfl` (reflexivity) tactic to show that the two sides are equal in each case. **Theorem 2: `Measure.prod_volume`** ``` theorem Measure.prod_volume {X Y} [MeasureSpace X] [MeasureSpace Y] : (Measure.prod (volume : Measure X) (volume : Measure Y)) = volume := by rfl ``` * **Arguments:** * `{X Y}`: Type variables representing two sets. * `[MeasureSpace X]`: A typeclass instance indicating that `X` is a measure space. * `[MeasureSpace Y]`: A typeclass instance indicating that `Y` is a measure space. * **Statement:** The theorem states that the product measure of the volumes of two measure spaces `X` and `Y` is equal to the volume itself. * **Proof:** The proof uses the `rfl` tactic, indicating that the two sides are definitionally equal. **Theorem 3: `ite_pull_enreal_toReal`** ``` theorem ite_pull_enreal_toReal (c : Prop) [Decidable c] (x y : ENNReal) : (if c then x else y).toReal = (if c then x.toReal else y.toReal) := by split_ifs <>; rfl ``` * **Arguments:** * `(c : Prop)`: A proposition `c`. * `[Decidable c]`: A typeclass instance indicating that `c` is decidable. * `(x y : ENNReal)`: Two extended non-negative real numbers, `x` and `y`. * **Statement:** The theorem states that converting the conditional extended non-negative real number `(if c then x else y)` to a real number is equivalent to converting each extended non-negative real number `x` and `y` individually and then applying the conditional. * **Proof:** The proof uses the `split_ifs` tactic to split the goal into cases based on the truth value of `c`, and then uses the `rfl` tactic to show that the two sides are equal in each case. ### Key Observations * The theorems all involve conditional statements (`if...then...else`) and measure-theoretic concepts. * The proofs are very concise, relying heavily on tactics like `split_ifs` and `rfl`, which suggest that the underlying definitions are well-suited for automated reasoning. * The use of typeclasses (`[MeasurableSpace X]`, `[Decidable c]`) indicates a strong emphasis on type safety and generality. ### Interpretation The code snippet demonstrates a formalization of mathematical concepts within a proof assistant system. The theorems likely serve as building blocks for more complex proofs in measure theory and real analysis. The use of conditional statements and typeclasses allows for precise and general statements about mathematical objects. The concise proofs suggest that the system is capable of automating significant portions of the reasoning process. The theorems relate to the properties of measures, conditional measures, and conversions between extended real numbers and real numbers. The overall purpose is to establish rigorous mathematical truths in a machine-checkable format.

## Code Screenshot: Lean 4 Theorem Proofs ### Overview The image is a screenshot of a code editor window (dark theme) displaying three mathematical theorem statements and their proofs written in the Lean 4 programming language, a dependently typed functional programming language and proof assistant. The content is purely textual code; there are no charts, diagrams, or data visualizations. The text is presented with syntax highlighting. ### Components/Axes The image contains a single component: a code editor window. - **Window Controls**: Three colored circles (red, yellow, green) are positioned in the top-left corner, typical of a macOS window interface. - **Code Content**: The main body contains three distinct theorem blocks. The text is monospaced and uses syntax highlighting: - Keywords like `theorem`, `by` are in a salmon/pink color. - Type names like `MeasurableSpace`, `Measure`, `ENNReal` are in a light blue/cyan. - Identifiers and variables are in a light gray/white. - Operators (`=`, `:=`, `:`, `<;>`) and punctuation are in white or light gray. - **Background**: The editor has a dark gray background (`#2d2d2d` approximate). The window itself is centered on a lighter gray background. ### Detailed Analysis / Content Details The following is a precise transcription of the textual content in the image. The language is **Lean 4**. **Theorem 1: `ite_pull_measureOf`** ```lean theorem ite_pull_measureOf {X} [MeasurableSpace X] (c : Prop) [Decidable c] (μ ν : Measure X) (A : Set X) : (if c then μ else ν) A = (if c then μ A else ν A) := by split_ifs <;> rfl ``` * **Statement**: For a type `X` with a `MeasurableSpace`, a decidable proposition `c`, two measures `μ` and `ν` on `X`, and a set `A` in `X`, the measure of `A` under the conditionally chosen measure (`μ` if `c` is true, `ν` otherwise) is equal to the conditionally chosen value of the measure of `A` (`μ A` if `c` is true, `ν A` otherwise). * **Proof**: The proof uses the tactic `split_ifs` to split the goal based on the condition `c`, followed by `rfl` (reflexivity) to close each subgoal. **Theorem 2: `Measure.prod_volume`** ```lean theorem Measure.prod_volume {X Y} [MeasureSpace X] [MeasureSpace Y] : (Measure.prod (volume : Measure X) (volume : Measure Y)) = volume := by rfl ``` * **Statement**: For types `X` and `Y` each with a `MeasureSpace`, the product measure of the `volume` measure on `X` and the `volume` measure on `Y` is equal to the `volume` measure (on the product space `X × Y`). * **Proof**: The proof is by reflexivity (`rfl`), indicating this is likely a definitional equality or a previously established lemma. **Theorem 3: `ite_pull_ennreal_toReal`** ```lean theorem ite_pull_ennreal_toReal (c : Prop) [Decidable c] (x y : ENNReal) : (if c then x else y).toReal = (if c then x.toReal else y.toReal) := by split_ifs <;> rfl ``` * **Statement**: For a decidable proposition `c` and two extended non-negative real numbers (`ENNReal`) `x` and `y`, converting the conditionally chosen number (`x` if `c` is true, `y` otherwise) to a real number (`toReal`) is equal to the conditionally chosen conversion (`x.toReal` if `c` is true, `y.toReal` otherwise). * **Proof**: Identical in structure to the first theorem: `split_ifs <;> rfl`. ### Key Observations 1. **Pattern**: Theorems 1 and 3 share an identical logical structure and proof tactic (`split_ifs <;> rfl`). They both "pull" an operation (`_A` for a measure, `.toReal`) out of a conditional (`if c then ... else ...`). 2. **Context**: The code is from the domain of **measure theory** and **formal verification**. It deals with concepts like measurable spaces, measures, product measures, and extended non-negative reals (`ENNReal`). 3. **Proof Style**: The proofs are extremely concise, relying on basic tactics (`rfl`, `split_ifs`), suggesting these are foundational or definitional lemmas within a larger library (likely Mathlib for Lean). 4. **Visual Layout**: The code is neatly formatted with consistent indentation. The theorems are separated by blank lines for clarity. ### Interpretation This image does not present data for interpretation in the statistical sense. Instead, it presents **formal mathematical statements** within a proof assistant. * **What it demonstrates**: The theorems establish basic, likely useful, properties for manipulating conditionals and measures/numbers in a formal setting. They ensure that applying an operation (like evaluating a measure on a set or converting an `ENNReal` to a `Real`) commutes with a conditional choice. This is crucial for simplifying proofs and definitions in formalized mathematics. * **Relationship between elements**: The three theorems are independent but thematically related. The first and third are direct analogs of each other in different mathematical domains (measure theory vs. real analysis). The second theorem is a separate, fundamental property about product measures. * **Significance**: In the context of formal verification (proving mathematical theorems with computer assistance), such lemmas are the essential "building blocks." They allow mathematicians and computer scientists to manipulate complex expressions step-by-step in a way that is guaranteed to be logically sound. The image captures a snippet of this meticulous, foundational work.

## Screenshot: Code Block with Three Theorems ### Overview The image shows a code snippet in a text editor with syntax highlighting. It contains three theorem definitions related to measure theory and real number conversions. The code uses functional programming constructs, conditional logic, and type annotations. ### Components/Axes - **Syntax Highlighting**: - Keywords (`theorem`, `if`, `then`, `else`, `by`, `split_ifs`, `toReal`) in red/magenta. - Variables (`X`, `Y`, `c`, `μ`, `v`, `A`, `x`, `y`) in teal. - Functions (`Measure`, `prod_volume`, `ite_pull_measureOf`, `ite_pull_ennreal_toReal`) in orange. - Logical operators (`:=`, `=`, `:`, `:Prop`, `:Decidable`, `:ENNReal`) in cyan. - **Structure**: - Three theorems separated by blank lines. - Each theorem has a name, parameters, and a body with conditional logic. ### Detailed Analysis 1. **Theorem 1: `ite_pull_measureOf`** - **Parameters**: - `X` (MeasurableSpace X) - `c` (Prop, Decidable c) - **Body**: ``` (μ v : Measure X) (A : Set X) : (if c then μ else v) A = (if c then μ A else v A) := by split_ifs <;> rfl ``` - Defines a measure pullback using a conditional (`if c then ... else ...`). - Uses `split_ifs` to split the conditional into cases. 2. **Theorem 2: `Measure.prod_volume`** - **Parameters**: - `X` (MeasureSpace X) - `Y` (MeasureSpace Y) - **Body**: ``` (Measure.prod (volume : Measure X) (volume : Measure Y)) = volume := by rfl ``` - Asserts that the product of two measures equals their combined volume. - Uses `rfl` (reflexivity) to confirm equality. 3. **Theorem 3: `ite_pull_ennreal_toReal`** - **Parameters**: - `c` (Prop, Decidable c) - `x y` (ENNReal) - **Body**: ``` (if c then x else y).toReal = (if c then x.toReal else y.toReal) := by split_ifs <;> rfl ``` - Converts extended real numbers (`ENNReal`) to real numbers (`Real`) conditionally. - Uses `split_ifs` to handle the conditional conversion. ### Key Observations - **Conditional Logic**: All theorems use `if c then ... else ...` constructs, suggesting a focus on decidable properties (`Decidable c`). - **Functional Programming**: Heavy use of lambda abstractions (`(μ v : Measure X) ...`) and function composition. - **Formal Verification**: Theorems are structured for proof assistants (e.g., Lean 4), with `by` and `rfl` indicating proof steps. - **Measure Theory**: Terms like `Measure`, `volume`, and `MeasurableSpace` indicate a focus on integration and measure spaces. ### Interpretation - **Purpose**: These theorems formalize properties of measure theory and real number conversions in a proof assistant. - `ite_pull_measureOf` defines how measures behave under conditional transformations. - `Measure.prod_volume` establishes the product measure’s volume as the product of individual volumes. - `ite_pull_ennreal_toReal` ensures conditional conversions from extended reals to standard reals preserve equality. - **Significance**: Critical for verifying correctness in systems involving probabilistic models, integration, or numerical computations. - **Anomalies**: No numerical data or visual trends; purely symbolic/logical assertions. ### Spatial Grounding - Theorems are vertically stacked, with each body indented under its name. - Syntax highlighting colors are consistent across the block, aiding readability. - No legends or axes, as this is code, not a chart.