1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsGLB.mul_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rcases lt_or_eq_of_le ha with (ha | rfl)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha : 0 ≤ a
hs : IsGLB s b
⊢ IsGLB ((fun b => a * b) '' s) (a * b)
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsGLB s b
ha : 0 < a
⊢ IsGLB ((fun b => a * b) '' s) (a * b)

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun b => 0 * b) '' s) (0 * b)

tactic: exact (OrderIso.mulLeft₀ _ ha).isGLB_image'.2 hs
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsGLB s b
ha : 0 < a
⊢ IsGLB ((fun b => a * b) '' s) (a * b)
state_after: no goals

tactic: simp_rw [zero_mul]
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun b => 0 * b) '' s) (0 * b)
state_after: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun a => 0) '' s) 0

tactic: rw [hs.nonempty.image_const]
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun a => 0) '' s) 0
state_after: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB {0} 0

tactic: exact isGLB_singleton
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB {0} 0
state_after: no goals
Theorem: List.Ico.map_add
File: Mathlib/Data/List/Intervals.lean

tactic: rw [Ico, Ico, map_add_range', Nat.add_sub_add_right m k, Nat.add_comm n k]
state_before: n m k : ℕ
⊢ map (fun x => k + x) (Ico n m) = Ico (n + k) (m + k)
state_after: no goals
Theorem: Batteries.AssocList.toList_modify
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: simp [cond]
state_before: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ (modify a f l).toList =
    List.replaceF
      (fun x =>
        match x with
        | (k, v) => bif k == a then some (a, f k v) else none)
      l.toList
state_after: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ (modify a f l).toList =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      l.toList

tactic: induction l with simp [List.replaceF]
| cons k v es ih => cases k == a <;> simp [ih]
state_before: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ (modify a f l).toList =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      l.toList
state_after: no goals

tactic: cases k == a <;> simp [ih]
state_before: case cons
α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a k : α
v : β
es : AssocList α β
ih :
  (modify a f es).toList =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      es.toList
⊢ (match k == a with
      | true => cons a (f k v) es
      | false => cons k v (modify a f es)).toList =
    match
      match k == a with
      | true => some (a, f k v)
      | false => none with
    | none =>
      (k, v) ::
        List.replaceF
          (fun x =>
            match x.fst == a with
            | true => some (a, f x.fst x.snd)
            | false => none)
          es.toList
    | some a => a :: es.toList
state_after: no goals
Theorem: bernsteinPolynomial.iterate_derivative_at_1_ne_zero
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: rw [bernsteinPolynomial.iterate_derivative_at_1 _ _ _ h, Ne, neg_one_pow_mul_eq_zero_iff, ←
  Nat.cast_succ, ← ascPochhammer_eval_cast, ← Nat.cast_zero, Nat.cast_inj]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ eval 1 ((⇑derivative)^[n - ν] (bernsteinPolynomial R n ν)) ≠ 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval ν.succ (ascPochhammer ℕ (n - ν)) = 0

tactic: exact (ascPochhammer_pos _ _ (Nat.succ_pos ν)).ne'
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval ν.succ (ascPochhammer ℕ (n - ν)) = 0
state_after: no goals
Theorem: MeasureTheory.integrable_withDensity_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: have : (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x := by simp [mul_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
⊢ Integrable g (μ.withDensity f) ↔ Integrable (fun x => g x * (f x).toReal) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
this : (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x
⊢ Integrable g (μ.withDensity f) ↔ Integrable (fun x => g x * (f x).toReal) μ

tactic: rw [this]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
this : (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x
⊢ Integrable g (μ.withDensity f) ↔ Integrable (fun x => g x * (f x).toReal) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
this : (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x
⊢ Integrable g (μ.withDensity f) ↔ Integrable (fun x => (f x).toReal • g x) μ

tactic: exact integrable_withDensity_iff_integrable_smul' hf hflt
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
this : (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x
⊢ Integrable g (μ.withDensity f) ↔ Integrable (fun x => (f x).toReal • g x) μ
state_after: no goals

tactic: simp [mul_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : Measurable f
hflt : ∀ᵐ (x : α) ∂μ, f x < ⊤
g : α → ℝ
⊢ (fun x => g x * (f x).toReal) = fun x => (f x).toReal • g x
state_after: no goals
Theorem: TensorProduct.finsuppLeft_symm_apply_single
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

tactic: simp [finsuppLeft, Finsupp.lsum]
state_before: R : Type u_1
inst✝⁵ : CommSemiring R
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
N : Type u_3
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
ι : Type u_4
inst✝ : DecidableEq ι
i : ι
m : M
n : N
⊢ (finsuppLeft R M N ι).symm (Finsupp.single i (m ⊗ₜ[R] n)) = Finsupp.single i m ⊗ₜ[R] n
state_after: no goals
Theorem: OnePoint.denseRange_coe
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [DenseRange, ← compl_infty]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝ : NoncompactSpace X
⊢ DenseRange some
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝ : NoncompactSpace X
⊢ Dense {∞}ᶜ

tactic: exact dense_compl_singleton _
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝ : NoncompactSpace X
⊢ Dense {∞}ᶜ
state_after: no goals
Theorem: Submodule.comap_op_one
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: ext
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ comap (↑(opLinearEquiv R)) 1 = 1
state_after: case h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n x✝ : A
⊢ x✝ ∈ comap (↑(opLinearEquiv R)) 1 ↔ x✝ ∈ 1

tactic: simp
state_before: case h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n x✝ : A
⊢ x✝ ∈ comap (↑(opLinearEquiv R)) 1 ↔ x✝ ∈ 1
state_after: no goals
Theorem: Complex.Gamma_ne_zero_of_re_pos
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

tactic: refine Gamma_ne_zero fun m => ?_
state_before: s : ℂ
hs : 0 < s.re
⊢ Gamma s ≠ 0
state_after: s : ℂ
hs : 0 < s.re
m : ℕ
⊢ s ≠ -↑m

tactic: contrapose! hs
state_before: s : ℂ
hs : 0 < s.re
m : ℕ
⊢ s ≠ -↑m
state_after: s : ℂ
m : ℕ
hs : s = -↑m
⊢ s.re ≤ 0

tactic: simpa only [hs, neg_re, ← ofReal_natCast, ofReal_re, neg_nonpos] using Nat.cast_nonneg _
state_before: s : ℂ
m : ℕ
hs : s = -↑m
⊢ s.re ≤ 0
state_after: no goals
Theorem: Submonoid.coe_sSup_of_directedOn
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: simp [mem_sSup_of_directedOn Sne hS]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ s ∈ S, ↑s
state_after: no goals
Theorem: ContinuousOn.tendstoUniformly
File: Mathlib/Topology/UniformSpace/Compact.lean

tactic: rcases LocallyCompactSpace.local_compact_nhds _ _ hxU with ⟨K, hxK, hKU, hK⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : UniformSpace α
inst✝³ : UniformSpace β
inst✝² : LocallyCompactSpace α
inst✝¹ : CompactSpace β
inst✝ : UniformSpace γ
f : α → β → γ
x : α
U : Set α
hxU : U ∈ 𝓝 x
h : ContinuousOn (↿f) (U ×ˢ univ)
⊢ TendstoUniformly f (f x) (𝓝 x)
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : UniformSpace α
inst✝³ : UniformSpace β
inst✝² : LocallyCompactSpace α
inst✝¹ : CompactSpace β
inst✝ : UniformSpace γ
f : α → β → γ
x : α
U : Set α
hxU : U ∈ 𝓝 x
h : ContinuousOn (↿f) (U ×ˢ univ)
K : Set α
hxK : K ∈ 𝓝 x
hKU : K ⊆ U
hK : IsCompact K
⊢ TendstoUniformly f (f x) (𝓝 x)

tactic: have : UniformContinuousOn (↿f) (K ×ˢ univ) :=
  IsCompact.uniformContinuousOn_of_continuous (hK.prod isCompact_univ)
    (h.mono <| prod_mono hKU Subset.rfl)
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : UniformSpace α
inst✝³ : UniformSpace β
inst✝² : LocallyCompactSpace α
inst✝¹ : CompactSpace β
inst✝ : UniformSpace γ
f : α → β → γ
x : α
U : Set α
hxU : U ∈ 𝓝 x
h : ContinuousOn (↿f) (U ×ˢ univ)
K : Set α
hxK : K ∈ 𝓝 x
hKU : K ⊆ U
hK : IsCompact K
⊢ TendstoUniformly f (f x) (𝓝 x)
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : UniformSpace α
inst✝³ : UniformSpace β
inst✝² : LocallyCompactSpace α
inst✝¹ : CompactSpace β
inst✝ : UniformSpace γ
f : α → β → γ
x : α
U : Set α
hxU : U ∈ 𝓝 x
h : ContinuousOn (↿f) (U ×ˢ univ)
K : Set α
hxK : K ∈ 𝓝 x
hKU : K ⊆ U
hK : IsCompact K
this : UniformContinuousOn (↿f) (K ×ˢ univ)
⊢ TendstoUniformly f (f x) (𝓝 x)

tactic: exact this.tendstoUniformly hxK
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : UniformSpace α
inst✝³ : UniformSpace β
inst✝² : LocallyCompactSpace α
inst✝¹ : CompactSpace β
inst✝ : UniformSpace γ
f : α → β → γ
x : α
U : Set α
hxU : U ∈ 𝓝 x
h : ContinuousOn (↿f) (U ×ˢ univ)
K : Set α
hxK : K ∈ 𝓝 x
hKU : K ⊆ U
hK : IsCompact K
this : UniformContinuousOn (↿f) (K ×ˢ univ)
⊢ TendstoUniformly f (f x) (𝓝 x)
state_after: no goals
Theorem: PowerSeries.order_X
File: Mathlib/RingTheory/PowerSeries/Order.lean

tactic: simpa only [Nat.cast_one] using order_monomial_of_ne_zero 1 (1 : R) one_ne_zero
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ X.order = 1
state_after: no goals
Theorem: summable_condensed_iff_of_nonneg
File: Mathlib/Analysis/PSeries.lean

tactic: convert summable_schlomilch_iff_of_nonneg h_nonneg h_mono (pow_pos zero_lt_two)
  (pow_right_strictMono one_lt_two) two_ne_zero h_succ_diff
state_before: f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_succ_diff : SuccDiffBounded 2 fun x => 2 ^ x
⊢ (Summable fun k => 2 ^ k * f (2 ^ k)) ↔ Summable f
state_after: case h.e'_1.h.e'_5.h.h.e'_5
f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_succ_diff : SuccDiffBounded 2 fun x => 2 ^ x
x✝ : ℕ
⊢ 2 ^ x✝ = ↑(2 ^ (x✝ + 1)) - ↑(2 ^ x✝)

tactic: simp [pow_succ, mul_two, two_mul]
state_before: case h.e'_1.h.e'_5.h.h.e'_5
f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_succ_diff : SuccDiffBounded 2 fun x => 2 ^ x
x✝ : ℕ
⊢ 2 ^ x✝ = ↑(2 ^ (x✝ + 1)) - ↑(2 ^ x✝)
state_after: no goals

tactic: intro n
state_before: f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
⊢ SuccDiffBounded 2 fun x => 2 ^ x
state_after: f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ (fun x => 2 ^ x) (n + 2) - (fun x => 2 ^ x) (n + 1) ≤ 2 • ((fun x => 2 ^ x) (n + 1) - (fun x => 2 ^ x) n)

tactic: simp [pow_succ, mul_two, two_mul]
state_before: f : ℕ → ℝ
h_nonneg : ∀ (n : ℕ), 0 ≤ f n
h_mono : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ (fun x => 2 ^ x) (n + 2) - (fun x => 2 ^ x) (n + 1) ≤ 2 • ((fun x => 2 ^ x) (n + 1) - (fun x => 2 ^ x) n)
state_after: no goals
Theorem: Cubic.leadingCoeff_of_c_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_b_eq_zero ha hb, leadingCoeff_linear hc]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c ≠ 0
⊢ P.toPoly.leadingCoeff = P.c
state_after: no goals
Theorem: Monotone.le_csInf_image
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: let f' : αᵒᵈ → βᵒᵈ := f
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : ConditionallyCompleteLattice β
f : α → β
h_mono : Monotone f
s : Set α
hs : s.Nonempty
B : α
hB : B ∈ lowerBounds s
⊢ f B ≤ sInf (f '' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : ConditionallyCompleteLattice β
f : α → β
h_mono : Monotone f
s : Set α
hs : s.Nonempty
B : α
hB : B ∈ lowerBounds s
f' : αᵒᵈ → βᵒᵈ := f
⊢ f B ≤ sInf (f '' s)

tactic: exact csSup_image_le (α := αᵒᵈ) (β := βᵒᵈ)
  (show Monotone f' from fun x y hxy => h_mono hxy) hs hB
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : ConditionallyCompleteLattice β
f : α → β
h_mono : Monotone f
s : Set α
hs : s.Nonempty
B : α
hB : B ∈ lowerBounds s
f' : αᵒᵈ → βᵒᵈ := f
⊢ f B ≤ sInf (f '' s)
state_after: no goals
Theorem: Rat.nonneg_total
File: Mathlib/Data/Rat/Defs.lean

tactic: simp_rw [← num_nonneg, num_neg_eq_neg_num, Int.neg_nonneg]
state_before: q a✝ b c a : ℚ
⊢ 0 ≤ a ∨ 0 ≤ -a
state_after: q a✝ b c a : ℚ
⊢ 0 ≤ a.num ∨ a.num ≤ 0

tactic: exact Int.le_total _ _
state_before: q a✝ b c a : ℚ
⊢ 0 ≤ a.num ∨ a.num ≤ 0
state_after: no goals
Theorem: ProbabilityTheory.IndepFun.exp_mul
File: Mathlib/Probability/Moments.lean

tactic: have h_meas : ∀ t, Measurable fun x => exp (t * x) := fun t => (measurable_id'.const_mul t).exp
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t✝ : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
s t : ℝ
⊢ IndepFun (fun ω => rexp (s * X ω)) (fun ω => rexp (t * Y ω)) μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t✝ : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
s t : ℝ
h_meas : ∀ (t : ℝ), Measurable fun x => rexp (t * x)
⊢ IndepFun (fun ω => rexp (s * X ω)) (fun ω => rexp (t * Y ω)) μ

tactic: change IndepFun ((fun x => exp (s * x)) ∘ X) ((fun x => exp (t * x)) ∘ Y) μ
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t✝ : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
s t : ℝ
h_meas : ∀ (t : ℝ), Measurable fun x => rexp (t * x)
⊢ IndepFun (fun ω => rexp (s * X ω)) (fun ω => rexp (t * Y ω)) μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t✝ : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
s t : ℝ
h_meas : ∀ (t : ℝ), Measurable fun x => rexp (t * x)
⊢ IndepFun ((fun x => rexp (s * x)) ∘ X) ((fun x => rexp (t * x)) ∘ Y) μ

tactic: exact IndepFun.comp h_indep (h_meas s) (h_meas t)
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t✝ : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
s t : ℝ
h_meas : ∀ (t : ℝ), Measurable fun x => rexp (t * x)
⊢ IndepFun ((fun x => rexp (s * x)) ∘ X) ((fun x => rexp (t * x)) ∘ Y) μ
state_after: no goals
Theorem: ProbabilityTheory.kernel.measurable_rnDeriv
File: Mathlib/Probability/Kernel/RadonNikodym.lean

tactic: simp_rw [rnDeriv_def]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
⊢ Measurable fun p => rnDeriv κ η p.1 p.2
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
⊢ Measurable fun p => ENNReal.ofReal (rnDerivAux κ (κ + η) p.1 p.2) / ENNReal.ofReal (1 - rnDerivAux κ (κ + η) p.1 p.2)

tactic: exact (measurable_rnDerivAux κ _).ennreal_ofReal.div
  (measurable_const.sub (measurable_rnDerivAux κ _)).ennreal_ofReal
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
⊢ Measurable fun p => ENNReal.ofReal (rnDerivAux κ (κ + η) p.1 p.2) / ENNReal.ofReal (1 - rnDerivAux κ (κ + η) p.1 p.2)
state_after: no goals
Theorem: Set.Finite.biUnion'
File: Mathlib/Data/Set/Finite.lean

tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
hs : s.Finite
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), (t i hi).Finite
⊢ (⋃ i, ⋃ (h : i ∈ s), t i h).Finite
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
hs : s.Finite
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), (t i hi).Finite
this : Finite ↑s
⊢ (⋃ i, ⋃ (h : i ∈ s), t i h).Finite

tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
hs : s.Finite
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), (t i hi).Finite
this : Finite ↑s
⊢ (⋃ i, ⋃ (h : i ∈ s), t i h).Finite
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
hs : s.Finite
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), (t i hi).Finite
this : Finite ↑s
⊢ (⋃ x, t ↑x ⋯).Finite

tactic: apply finite_iUnion fun i : s => ht i.1 i.2
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
hs : s.Finite
t : (i : ι) → i ∈ s → Set α
ht : ∀ (i : ι) (hi : i ∈ s), (t i hi).Finite
this : Finite ↑s
⊢ (⋃ x, t ↑x ⋯).Finite
state_after: no goals
Theorem: Set.pi_nonempty_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [Classical.skolem, Set.Nonempty]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ (s.pi t).Nonempty ↔ ∀ (i : ι), ∃ x, i ∈ s → x ∈ t i
state_after: no goals
Theorem: WittVector.bind₁_frobeniusPoly_wittPolynomial
File: Mathlib/RingTheory/WittVector/Frobenius.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (bind₁ (frobeniusPoly p)) (wittPolynomial p ℤ n) = wittPolynomial p ℤ (n + 1)
state_after: case a
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (MvPolynomial.map (Int.castRingHom ℚ)) ((bind₁ (frobeniusPoly p)) (wittPolynomial p ℤ n)) =
    (MvPolynomial.map (Int.castRingHom ℚ)) (wittPolynomial p ℤ (n + 1))

tactic: simp only [map_bind₁, map_frobeniusPoly, bind₁_frobeniusPolyRat_wittPolynomial,
  map_wittPolynomial]
state_before: case a
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (MvPolynomial.map (Int.castRingHom ℚ)) ((bind₁ (frobeniusPoly p)) (wittPolynomial p ℤ n)) =
    (MvPolynomial.map (Int.castRingHom ℚ)) (wittPolynomial p ℤ (n + 1))
state_after: no goals
Theorem: NNRat.divNat_zero
File: Mathlib/Data/NNRat/Defs.lean

tactic: simp [divNat]
state_before: p q : ℚ≥0
n₁ n₂ d₁ d₂ d n : ℕ
⊢ divNat n 0 = 0
state_after: p q : ℚ≥0
n₁ n₂ d₁ d₂ d n : ℕ
⊢ ⟨0, ⋯⟩ = 0

tactic: rfl
state_before: p q : ℚ≥0
n₁ n₂ d₁ d₂ d n : ℕ
⊢ ⟨0, ⋯⟩ = 0
state_after: no goals
Theorem: CategoryTheory.Adjunction.map_restrictFullyFaithful_unit_app
File: Mathlib/CategoryTheory/Adjunction/Restrict.lean

tactic: simp [restrictFullyFaithful]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : C
⊢ iC.map ((restrictFullyFaithful hiC hiD adj comm1 comm2).unit.app X) =
    adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫ comm2.hom.app (L.obj X)
state_after: no goals
Theorem: Batteries.AssocList.find?_eq_findEntry?
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l <;> simp [find?, List.find?_cons]
state_before: α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
l : AssocList α β
⊢ find? a l = Option.map (fun x => x.snd) (findEntry? a l)
state_after: case cons
α : Type u_1
β : Type u_2
inst✝ : BEq α
a key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ : find? a tail✝ = Option.map (fun x => x.snd) (findEntry? a tail✝)
⊢ (match key✝ == a with
    | true => some value✝
    | false => find? a tail✝) =
    Option.map (fun x => x.snd)
      (match key✝ == a with
      | true => some (key✝, value✝)
      | false => List.find? (fun x => x.fst == a) tail✝.toList)

tactic: split <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
inst✝ : BEq α
a key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ : find? a tail✝ = Option.map (fun x => x.snd) (findEntry? a tail✝)
⊢ (match key✝ == a with
    | true => some value✝
    | false => find? a tail✝) =
    Option.map (fun x => x.snd)
      (match key✝ == a with
      | true => some (key✝, value✝)
      | false => List.find? (fun x => x.fst == a) tail✝.toList)
state_after: no goals
Theorem: Set.univ_pi_piecewise_univ
File: Mathlib/Data/Set/Function.lean

tactic: simp
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
π : α✝ → Type u_5
δ : α✝ → Sort u_6
s✝ : Set α✝
f g : (i : α✝) → δ i
inst✝¹ : (j : α✝) → Decidable (j ∈ s✝)
ι : Type u_7
α : ι → Type u_8
s : Set ι
t : (i : ι) → Set (α i)
inst✝ : (x : ι) → Decidable (x ∈ s)
⊢ univ.pi (s.piecewise t fun x => univ) = s.pi t
state_after: no goals