ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.preCDF_le_one
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
⊢ ∀ᵐ (a : α) ∂ρ.fst, ∀ (r : ℚ), preCDF ρ r a ≤ 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
⊢ ∀ (i : ℚ), ∀ᵐ (a : α) ∂ρ.fst, preCDF ρ i a ≤ 1
tactic: rw [ae_all_iff]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
⊢ ∀ (i : ℚ), ∀ᵐ (a : α) ∂ρ.fst, preCDF ρ i a ≤ 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
s : Set α
hs : MeasurableSet s
x✝ : ρ.fst s < ⊤
⊢ ∫⁻ (x : α) in s, preCDF ρ r x ∂ρ.fst ≤ ∫⁻ (x : α) in s, 1 ∂ρ.fst
tactic: refine fun r ↦ ae_le_of_forall_setLIntegral_le_of_sigmaFinite measurable_preCDF fun s hs _ ↦ ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
s : Set α
hs : MeasurableSet s
x✝ : ρ.fst s < ⊤
⊢ ∫⁻ (x : α) in s, preCDF ρ r x ∂ρ.fst ≤ ∫⁻ (x : α) in s, 1 ∂ρ.fst
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
s : Set α
hs : MeasurableSet s
x✝ : ρ.fst s < ⊤
⊢ (ρ.IicSnd ↑r) s ≤ ∫⁻ (x : α) in s, 1 ∂ρ.fst
tactic: rw [setLIntegral_preCDF_fst ρ r hs]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
s : Set α
hs : MeasurableSet s
x✝ : ρ.fst s < ⊤
⊢ (ρ.IicSnd ↑r) s ≤ ∫⁻ (x : α) in s, 1 ∂ρ.fst
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
s : Set α
hs : MeasurableSet s
x✝ : ρ.fst s < ⊤
⊢ (ρ.IicSnd ↑r) s ≤ ρ.fst s
tactic: simp only [Pi.one_apply, lintegral_one, Measure.restrict_apply, MeasurableSet.univ, univ_inter]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
s : Set α
hs : MeasurableSet s
x✝ : ρ.fst s < ⊤
⊢ (ρ.IicSnd ↑r) s ≤ ρ.fst s
state_after: no goals
tactic: exact Measure.IicSnd_le_fst ρ r s
Theorem: PiLp.lipschitzWith_equiv_aux
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
⊢ LipschitzWith 1 ⇑(WithLp.equiv p ((i : ι) → β i))
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
x y : WithLp p ((i : ι) → β i)
⊢ edist ((WithLp.equiv p ((i : ι) → β i)) x) ((WithLp.equiv p ((i : ι) → β i)) y) ≤ ↑1 * edist x y
tactic: intro x y
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
x y : WithLp p ((i : ι) → β i)
⊢ edist ((WithLp.equiv p ((i : ι) → β i)) x) ((WithLp.equiv p ((i : ι) → β i)) y) ≤ ↑1 * edist x y
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
x y : WithLp p ((i : ι) → β i)
⊢ ∀ (b : ι), edist (x b) (y b) ≤ edist x y
tactic: simp_rw [ENNReal.coe_one, one_mul, edist_pi_def, Finset.sup_le_iff, Finset.mem_univ,
    forall_true_left, WithLp.equiv_pi_apply]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
x y : WithLp p ((i : ι) → β i)
⊢ ∀ (b : ι), edist (x b) (y b) ≤ edist x y
state_after: case inl
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : (i : ι) → PseudoMetricSpace (α i)
inst✝² : (i : ι) → PseudoEMetricSpace (β i)
inst✝¹ : Fintype ι
inst✝ : Fact (1 ≤ ⊤)
x y : WithLp ⊤ ((i : ι) → β i)
⊢ ∀ (b : ι), edist (x b) (y b) ≤ edist x y

case inr
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
x y : WithLp p ((i : ι) → β i)
h : 1 ≤ p.toReal
⊢ ∀ (b : ι), edist (x b) (y b) ≤ edist x y
tactic: rcases p.dichotomy with (rfl | h)
Theorem: Down.mem_compression_of_insert_mem_compression
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
h : insert a s ∈ 𝓓 a 𝒜
⊢ s ∈ 𝓓 a 𝒜
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
h : insert a s ∈ 𝓓 a 𝒜
ha : a ∈ s
⊢ s ∈ 𝓓 a 𝒜

case neg
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
h : insert a s ∈ 𝓓 a 𝒜
ha : a ∉ s
⊢ s ∈ 𝓓 a 𝒜
tactic: by_cases ha : a ∈ s
Theorem: Int.le_floor_add_floor
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌊a + b⌋ - 1 ≤ ⌊a⌋ + ⌊b⌋
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ ↑⌊b⌋
tactic: rw [← sub_le_iff_le_add, le_floor, Int.cast_sub, sub_le_comm, Int.cast_sub, Int.cast_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ ↑⌊b⌋
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ b - 1
tactic: refine le_trans ?_ (sub_one_lt_floor _).le
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ b - 1
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ ≤ a + b
tactic: rw [sub_le_iff_le_add', ← add_sub_assoc, sub_le_sub_iff_right]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ ≤ a + b
state_after: no goals
tactic: exact floor_le _
Theorem: CategoryTheory.toQuotientPaths_obj_as
File: Mathlib/CategoryTheory/PathCategory.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
⊢ pathsHomRel C (𝟙 X).toPath
    (𝟙
      ({ obj := fun X => { as := X },
              map := fun {X Y} f => Quot.mk (Quotient.CompClosure (pathsHomRel C)) f.toPath }.obj
          X).as)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ pathsHomRel C (f ≫ g).toPath (f.toPath ≫ g.toPath)
state_after: no goals
tactic: simp
Theorem: Dense.prod
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
hs : Dense s
ht : Dense t
x : X × Y
⊢ x ∈ closure (s ×ˢ t)
state_after: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
hs : Dense s
ht : Dense t
x : X × Y
⊢ x ∈ closure s ×ˢ closure t
tactic: rw [closure_prod_eq]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
hs : Dense s
ht : Dense t
x : X × Y
⊢ x ∈ closure s ×ˢ closure t
state_after: no goals
tactic: exact ⟨hs x.1, ht x.2⟩
Theorem: MeasureTheory.Measure.restrict_apply_eq_zero
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
ht : MeasurableSet t
⊢ (μ.restrict s) t = 0 ↔ μ (t ∩ s) = 0
state_after: no goals
tactic: rw [restrict_apply ht]
Theorem: DFinsupp.update_eq_erase_add_single
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ update i f b = erase i f + single i b
state_after: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
⊢ (update i f b) j = (erase i f + single i b) j
tactic: ext j
state_before: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
⊢ (update i f b) j = (erase i f + single i b) j
state_after: case h.inl
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ (update i f b) i = (erase i f + single i b) i

case h.inr
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
h : i ≠ j
⊢ (update i f b) j = (erase i f + single i b) j
tactic: rcases eq_or_ne i j with (rfl | h)
Theorem: Equiv.Perm.signAux_swap
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
x y : Fin 0
⊢ x ≠ y → (swap x y).signAux = -1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
x y : Fin 0
_hxy✝ : x ≠ y
⊢ (swap x y).signAux = -1
tactic: intro
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
x y : Fin 0
_hxy✝ : x ≠ y
⊢ (swap x y).signAux = -1
state_after: no goals
tactic: exact Fin.elim0 x
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
x y : Fin 1
⊢ x ≠ y → (swap x y).signAux = -1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
x y : Fin 1
⊢ ¬x = y →
    (∏ x_1 ∈ finPairsLT 1,
        if
            (if x_1.fst = x then y else if x_1.fst = y then x else x_1.fst) ≤
              if x_1.snd = x then y else if x_1.snd = y then x else x_1.snd then
          -1
        else 1) =
      -1
tactic: dsimp [signAux, swap, swapCore]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
x y : Fin 1
⊢ ¬x = y →
    (∏ x_1 ∈ finPairsLT 1,
        if
            (if x_1.fst = x then y else if x_1.fst = y then x else x_1.fst) ≤
              if x_1.snd = x then y else if x_1.snd = y then x else x_1.snd then
          -1
        else 1) =
      -1
state_after: no goals
tactic: simp only [eq_iff_true_of_subsingleton, not_true, ite_true, le_refl, prod_const,
               IsEmpty.forall_iff]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
⊢ (swap x y).signAux = -1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ (swap x y).signAux = -1
tactic: have h2n : 2 ≤ n + 2 := by exact le_add_self
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ (swap x y).signAux = -1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ IsConj (swap x y).signAux (swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux
tactic: rw [← isConj_iff_eq, ← signAux_swap_zero_one h2n]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
x y : Fin (n + 2)
hxy : x ≠ y
h2n : 2 ≤ n + 2
⊢ IsConj (swap x y).signAux (swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux
state_after: no goals
tactic: exact (MonoidHom.mk' signAux signAux_mul).map_isConj
      (isConj_swap hxy (by exact of_decide_eq_true rfl))
Theorem: OreLocalization.zero_oreDiv'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : MonoidWithZero R
S : Submonoid R
inst✝ : OreSet S
s : ↥S
⊢ 0 /ₒ s = 0
state_after: R : Type u_1
inst✝¹ : MonoidWithZero R
S : Submonoid R
inst✝ : OreSet S
s : ↥S
⊢ ∃ u v, u • 0 = v • 0 ∧ ↑u * ↑1 = v * ↑s
tactic: rw [OreLocalization.zero_def, oreDiv_eq_iff]
state_before: R : Type u_1
inst✝¹ : MonoidWithZero R
S : Submonoid R
inst✝ : OreSet S
s : ↥S
⊢ ∃ u v, u • 0 = v • 0 ∧ ↑u * ↑1 = v * ↑s
state_after: no goals
tactic: exact ⟨s, 1, by simp [Submonoid.smul_def]⟩
Theorem: SimpleGraph.edgeSet_fromEdgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ (fromEdgeSet s).edgeSet = s \ {e | e.IsDiag}
state_after: case h
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ (fromEdgeSet s).edgeSet ↔ e ∈ s \ {e | e.IsDiag}
tactic: ext e
state_before: case h
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ (fromEdgeSet s).edgeSet ↔ e ∈ s \ {e | e.IsDiag}
state_after: no goals
tactic: exact Sym2.ind (by simp) e
Theorem: List.findIdx?_of_eq_some
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
i : Nat
xs : List α
p : α → Bool
w : findIdx? p xs = some i
⊢ match xs.get? i with
  | some a => p a = true
  | none => false = true
state_after: no goals
tactic: induction xs generalizing i with
  | nil => simp_all
  | cons x xs ih =>
    simp_all only [findIdx?_cons, Nat.zero_add, findIdx?_succ]
    split at w <;> cases i <;> simp_all
Theorem: MeasureTheory.exists_le_lintegral
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t N : Set α
f : α → ℝ≥0∞
inst✝ : IsProbabilityMeasure μ
hf : AEMeasurable f μ
⊢ ∃ x, f x ≤ ∫⁻ (a : α), f a ∂μ
state_after: no goals
tactic: simpa only [laverage_eq_lintegral] using exists_le_laverage (IsProbabilityMeasure.ne_zero μ) hf
Theorem: Cardinal.powerlt_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c✝ : Cardinal.{?u.246298}
a b c : Cardinal.{u}
⊢ a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c
state_after: α β : Type u
c✝ : Cardinal.{?u.246298}
a b c : Cardinal.{u}
⊢ (∀ (i : ↑(Iio b)), a ^ ↑i ≤ c) ↔ ∀ x < b, a ^ x ≤ c

case h
α β : Type u
c✝ : Cardinal.{?u.246298}
a b c : Cardinal.{u}
⊢ BddAbove (range fun c => a ^ ↑c)
tactic: rw [powerlt, ciSup_le_iff']
Theorem: Finset.inf_union
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
s s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq β
c : α
⊢ c ≤ (s₁ ∪ s₂).inf f ↔ c ≤ s₁.inf f ⊓ s₂.inf f
state_after: no goals
tactic: simp [or_imp, forall_and]
Theorem: List.trop_minimum
File: Mathlib/Algebra/Tropical/BigOperators.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
l : List R
⊢ trop l.minimum = (map (trop ∘ WithTop.some) l).sum
state_after: case nil
R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
⊢ trop [].minimum = (map (trop ∘ WithTop.some) []).sum

case cons
R : Type u_1
S : Type u_2
inst✝ : LinearOrder R
hd : R
tl : List R
IH : trop tl.minimum = (map (trop ∘ WithTop.some) tl).sum
⊢ trop (hd :: tl).minimum = (map (trop ∘ WithTop.some) (hd :: tl)).sum
tactic: induction' l with hd tl IH
Theorem: CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse_obj
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.105888, u_1} C
inst✝ : HasShift C ℤ
T₁ T₂ : Triangle Cᵒᵖ
φ : T₁ ⟶ T₂
⊢ ((Triangle.mk T₂.mor₂.unop T₂.mor₁.unop
            (((opShiftFunctorEquivalence C 1).unitIso.inv.app T₂.obj₁).unop ≫
              (shiftFunctor C 1).map T₂.mor₃.unop)).mor₃ ≫
        (shiftFunctor C 1).map φ.hom₃.unop).op =
    (φ.hom₁.unop ≫
        (Triangle.mk T₁.mor₂.unop T₁.mor₁.unop
            (((opShiftFunctorEquivalence C 1).unitIso.inv.app T₁.obj₁).unop ≫
              (shiftFunctor C 1).map T₁.mor₃.unop)).mor₃).op
state_after: C : Type u_1
inst✝¹ : Category.{?u.105888, u_1} C
inst✝ : HasShift C ℤ
T₁ T₂ : Triangle Cᵒᵖ
φ : T₁ ⟶ T₂
⊢ ((shiftFunctor C 1).map φ.hom₃.unop).op ≫
      ((shiftFunctor C 1).map T₂.mor₃.unop).op ≫ (opShiftFunctorEquivalence C 1).unitIso.inv.app T₂.obj₁ =
    (((shiftFunctor C 1).map T₁.mor₃.unop).op ≫ (opShiftFunctorEquivalence C 1).unitIso.inv.app T₁.obj₁) ≫ φ.hom₁
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.105888, u_1} C
inst✝ : HasShift C ℤ
T₁ T₂ : Triangle Cᵒᵖ
φ : T₁ ⟶ T₂
⊢ ((shiftFunctor C 1).map φ.hom₃.unop).op ≫
      ((shiftFunctor C 1).map T₂.mor₃.unop).op ≫ (opShiftFunctorEquivalence C 1).unitIso.inv.app T₂.obj₁ =
    (((shiftFunctor C 1).map T₁.mor₃.unop).op ≫ (opShiftFunctorEquivalence C 1).unitIso.inv.app T₁.obj₁) ≫ φ.hom₁
state_after: no goals
tactic: rw [assoc, ← opShiftFunctorEquivalence_unitIso_inv_naturality,
          ← op_comp_assoc, ← Functor.map_comp, ← unop_comp, ← φ.comm₃,
          unop_comp, Functor.map_comp, op_comp, assoc]
Theorem: Continuous.div₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁵ : GroupWithZero G₀
inst✝⁴ : TopologicalSpace G₀
inst✝³ : HasContinuousInv₀ G₀
inst✝² : ContinuousMul G₀
f g : α → G₀
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set α
a : α
hf : Continuous f
hg : Continuous g
h₀ : ∀ (x : α), g x ≠ 0
⊢ Continuous fun x => f x / g x
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ h₀)
Theorem: Monoid.PushoutI.of_apply_eq_base
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Monoid (G i)
inst✝ : Monoid H
φ : (i : ι) → H →* G i
i : ι
x : H
⊢ (of i) ((φ i) x) = (base φ) x
state_after: no goals
tactic: rw [← MonoidHom.comp_apply, of_comp_eq_base]
Theorem: Int.dvd_of_mul_dvd_mul_right
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
ha : a ≠ 0
h : m * a ∣ n * a
⊢ a * m ∣ a * n
state_after: no goals
tactic: simpa [Int.mul_comm] using h
Theorem: List.aemeasurable_sum'
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
l : List (α → M)
hl : ∀ f ∈ l, AEMeasurable f μ
⊢ AEMeasurable l.prod μ
state_after: case nil
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
hl : ∀ f ∈ [], AEMeasurable f μ
⊢ AEMeasurable [].prod μ

case cons
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : α → M
l : List (α → M)
ihl : (∀ f ∈ l, AEMeasurable f μ) → AEMeasurable l.prod μ
hl : ∀ f_1 ∈ f :: l, AEMeasurable f_1 μ
⊢ AEMeasurable (f :: l).prod μ
tactic: induction' l with f l ihl
state_before: case cons
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : α → M
l : List (α → M)
ihl : (∀ f ∈ l, AEMeasurable f μ) → AEMeasurable l.prod μ
hl : ∀ f_1 ∈ f :: l, AEMeasurable f_1 μ
⊢ AEMeasurable (f :: l).prod μ
state_after: case cons
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : α → M
l : List (α → M)
ihl : (∀ f ∈ l, AEMeasurable f μ) → AEMeasurable l.prod μ
hl : AEMeasurable f μ ∧ ∀ x ∈ l, AEMeasurable x μ
⊢ AEMeasurable (f :: l).prod μ
tactic: rw [List.forall_mem_cons] at hl
state_before: case cons
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : α → M
l : List (α → M)
ihl : (∀ f ∈ l, AEMeasurable f μ) → AEMeasurable l.prod μ
hl : AEMeasurable f μ ∧ ∀ x ∈ l, AEMeasurable x μ
⊢ AEMeasurable (f :: l).prod μ
state_after: case cons
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : α → M
l : List (α → M)
ihl : (∀ f ∈ l, AEMeasurable f μ) → AEMeasurable l.prod μ
hl : AEMeasurable f μ ∧ ∀ x ∈ l, AEMeasurable x μ
⊢ AEMeasurable (f * l.prod) μ
tactic: rw [List.prod_cons]
state_before: case cons
α✝ : Type u_1
M : Type u_2
α : Type u_3
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : α → M
l : List (α → M)
ihl : (∀ f ∈ l, AEMeasurable f μ) → AEMeasurable l.prod μ
hl : AEMeasurable f μ ∧ ∀ x ∈ l, AEMeasurable x μ
⊢ AEMeasurable (f * l.prod) μ
state_after: no goals
tactic: exact hl.1.mul (ihl hl.2)
Theorem: QuadraticMap.associated_left_inverse
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
inst✝⁴ : CommSemiring S
inst✝³ : Algebra S R
inst✝² : Module S N
inst✝¹ : IsScalarTower S R N
inst✝ : Invertible 2
B₁ : BilinMap R M R
Q : QuadraticMap R M N
h : LinearMap.IsSymm B₁
x y : M
⊢ (((associatedHom S) B₁.toQuadraticMap) x) y = (B₁ x) y
state_after: no goals
tactic: rw [associated_toQuadraticMap, ← h.eq x y, RingHom.id_apply, ← two_mul, ← smul_mul_assoc,
      smul_eq_mul, invOf_mul_self, one_mul]
Theorem: op_geom_sum
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Semiring α
x : α
n : ℕ
⊢ op (∑ i ∈ range n, x ^ i) = ∑ i ∈ range n, op x ^ i
state_after: no goals
tactic: simp