ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContinuousLinearMap.isPositive_zero
File: Mathlib/Analysis/InnerProductSpace/Positive.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
⊢ IsPositive 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
x : E
⊢ 0 ≤ reApplyInnerSelf 0 x
tactic: refine ⟨.zero _, fun x => ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
x : E
⊢ 0 ≤ reApplyInnerSelf 0 x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
x : E
⊢ 0 ≤ re ⟪0 x, x⟫_𝕜
tactic: change 0 ≤ re ⟪_, _⟫
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
x : E
⊢ 0 ≤ re ⟪0 x, x⟫_𝕜
state_after: no goals
tactic: rw [zero_apply, inner_zero_left, ZeroHomClass.map_zero]
Theorem: natCast_mem
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

Proof steps:
state_before: S : Type u_1
R : Type u_2
inst✝² : AddMonoidWithOne R
inst✝¹ : SetLike S R
s : S
inst✝ : AddSubmonoidWithOneClass S R
n : ℕ
⊢ ↑n ∈ s
state_after: no goals
tactic: induction n <;> simp [zero_mem, add_mem, one_mem, *]
Theorem: isLUB_csSup'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s✝ : Set α
f : ι → α
a : α
s : Set α
hs : BddAbove s
⊢ IsLUB s (sSup s)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set α
f : ι → α
a : α
hs : BddAbove ∅
⊢ IsLUB ∅ (sSup ∅)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s✝ : Set α
f : ι → α
a : α
s : Set α
hs : BddAbove s
hne : s.Nonempty
⊢ IsLUB s (sSup s)
tactic: rcases eq_empty_or_nonempty s with (rfl | hne)
Theorem: List.kunion_nil
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
head✝ : Sigma β
l : List (Sigma β)
⊢ (head✝ :: l).kunion [] = head✝ :: l
state_after: no goals
tactic: rw [kunion, kerase_nil, kunion_nil]
Theorem: Valuation.isEquiv_iff_val_sub_one_lt_one
File: Mathlib/RingTheory/Valuation/Basic.lean

Proof steps:
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ v.IsEquiv v' ↔ ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ (∀ {x : K}, v x < 1 ↔ v' x < 1) ↔ ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1
tactic: rw [isEquiv_iff_val_lt_one]
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ (∀ {x : K}, v x < 1 ↔ v' x < 1) ↔ ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1
state_after: no goals
tactic: exact (Equiv.subRight 1).surjective.forall
Theorem: Traversable.map_traverse'
File: Mathlib/Control/Traversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → G β
h : β → γ
⊢ traverse (map h ∘ g) = map (map h) ∘ traverse g
state_after: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → G β
h : β → γ
x✝ : t α
⊢ traverse (map h ∘ g) x✝ = (map (map h) ∘ traverse g) x✝
tactic: ext
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → G β
h : β → γ
x✝ : t α
⊢ traverse (map h ∘ g) x✝ = (map (map h) ∘ traverse g) x✝
state_after: no goals
tactic: rw [comp_apply, map_traverse]
Theorem: CategoryTheory.Functor.commShiftOfLocalization.iso_hom_app
File: Mathlib/CategoryTheory/Shift/Localization.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝¹² : Category.{v₁, u₁} C
inst✝¹¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝¹⁰ : Category.{v₃, u₃} E
L : C ⥤ D
W : MorphismProperty C
inst✝⁹ : L.IsLocalization W
A : Type w
inst✝⁸ : AddMonoid A
inst✝⁷ : HasShift C A
inst✝⁶ : W.IsCompatibleWithShift A
inst✝⁵ : W.HasLocalization
F : C ⥤ E
F' : D ⥤ E
inst✝⁴ : Lifting L W F F'
inst✝³ : HasShift D A
inst✝² : HasShift E A
inst✝¹ : L.CommShift A
inst✝ : F.CommShift A
a : A
X : C
⊢ (iso L W F F' a).hom.app (L.obj X) =
    F'.map ((L.commShiftIso a).inv.app X) ≫
      (Lifting.iso L W F F').hom.app ((shiftFunctor C a).obj X) ≫
        (F.commShiftIso a).hom.app X ≫ (shiftFunctor E a).map ((Lifting.iso L W F F').inv.app X)
state_after: no goals
tactic: simp [commShiftOfLocalization.iso]
Theorem: stronglyMeasurableAt_bot
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
l l' : Filter α
f✝ g : α → β
μ ν : Measure α
f : α → β
⊢ AEStronglyMeasurable f (μ.restrict ∅)
state_after: no goals
tactic: simp
Theorem: Nat.not_exists_sq
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hl : m * m < n
hr : n < (m + 1) * (m + 1)
⊢ ¬∃ t, t * t = n
state_after: case intro
a b c d m k : ℕ
p q : ℕ → Prop
t : ℕ
hl : m * m < t * t
hr : t * t < (m + 1) * (m + 1)
⊢ False
tactic: rintro ⟨t, rfl⟩
state_before: case intro
a b c d m k : ℕ
p q : ℕ → Prop
t : ℕ
hl : m * m < t * t
hr : t * t < (m + 1) * (m + 1)
⊢ False
state_after: case intro
a b c d m k : ℕ
p q : ℕ → Prop
t : ℕ
hl : m * m < t * t
hr : t * t < (m + 1) * (m + 1)
h1 : m < t
⊢ False
tactic: have h1 : m < t := Nat.mul_self_lt_mul_self_iff.1 hl
state_before: case intro
a b c d m k : ℕ
p q : ℕ → Prop
t : ℕ
hl : m * m < t * t
hr : t * t < (m + 1) * (m + 1)
h1 : m < t
⊢ False
state_after: case intro
a b c d m k : ℕ
p q : ℕ → Prop
t : ℕ
hl : m * m < t * t
hr : t * t < (m + 1) * (m + 1)
h1 : m < t
h2 : t < m + 1
⊢ False
tactic: have h2 : t < m + 1 := Nat.mul_self_lt_mul_self_iff.1 hr
state_before: case intro
a b c d m k : ℕ
p q : ℕ → Prop
t : ℕ
hl : m * m < t * t
hr : t * t < (m + 1) * (m + 1)
h1 : m < t
h2 : t < m + 1
⊢ False
state_after: no goals
tactic: exact (not_lt_of_ge <| le_of_lt_succ h2) h1
Theorem: Multiset.prod_lt_prod_of_nonempty'
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCancelCommMonoid α
s : Multiset ι
f g : ι → α
hs : s ≠ ∅
hfg : ∀ i ∈ s, f i < g i
⊢ (map f s).prod < (map g s).prod
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCancelCommMonoid α
s : Multiset ι
f g : ι → α
hs : s ≠ ∅
hfg : ∀ i ∈ s, f i < g i
i : ι
hi : i ∈ s
⊢ (map f s).prod < (map g s).prod
tactic: obtain ⟨i, hi⟩ := exists_mem_of_ne_zero hs
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCancelCommMonoid α
s : Multiset ι
f g : ι → α
hs : s ≠ ∅
hfg : ∀ i ∈ s, f i < g i
i : ι
hi : i ∈ s
⊢ (map f s).prod < (map g s).prod
state_after: no goals
tactic: exact prod_lt_prod' (fun i hi => le_of_lt (hfg i hi)) ⟨i, hi, hfg i hi⟩
Theorem: ContinuousMultilinearMap.opNNNorm_le_iff
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
C : ℝ≥0
⊢ ‖f‖₊ ≤ C ↔ ∀ (m : (i : ι) → E i), ‖f m‖₊ ≤ C * ∏ i : ι, ‖m i‖₊
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
C : ℝ≥0
⊢ ↑‖f‖₊ ≤ ↑C ↔ ∀ (m : (i : ι) → E i), ↑‖f m‖₊ ≤ ↑(C * ∏ i : ι, ‖m i‖₊)
tactic: simp only [← NNReal.coe_le_coe]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
C : ℝ≥0
⊢ ↑‖f‖₊ ≤ ↑C ↔ ∀ (m : (i : ι) → E i), ↑‖f m‖₊ ≤ ↑(C * ∏ i : ι, ‖m i‖₊)
state_after: no goals
tactic: simp [opNorm_le_iff _ C.coe_nonneg, NNReal.coe_prod]
Theorem: HomologicalComplex.d_comp_d
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
⊢ C.d i j ≫ C.d j k = 0
state_after: case pos
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : c.Rel i j
⊢ C.d i j ≫ C.d j k = 0

case neg
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : ¬c.Rel i j
⊢ C.d i j ≫ C.d j k = 0
tactic: by_cases hij : c.Rel i j
Theorem: List.cycleType_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.Nodup
hn : 2 ≤ l.length
⊢ l.attach.formPerm.cycleType = {l.length}
state_after: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.Nodup
hn : 2 ≤ l.attach.length
⊢ l.attach.formPerm.cycleType = {l.length}
tactic: rw [← length_attach] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.Nodup
hn : 2 ≤ l.attach.length
⊢ l.attach.formPerm.cycleType = {l.length}
state_after: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.attach.Nodup
hn : 2 ≤ l.attach.length
⊢ l.attach.formPerm.cycleType = {l.length}
tactic: rw [← nodup_attach] at hl
state_before: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.attach.Nodup
hn : 2 ≤ l.attach.length
⊢ l.attach.formPerm.cycleType = {l.length}
state_after: α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.attach.Nodup
hn : 2 ≤ l.attach.length
⊢ ↑(map (Finset.card ∘ support) [l.attach.formPerm]) = {l.length}

case h0
α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.attach.Nodup
hn : 2 ≤ l.attach.length
⊢ [l.attach.formPerm].prod = l.attach.formPerm

case h1
α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.attach.Nodup
hn : 2 ≤ l.attach.length
⊢ ∀ σ ∈ [l.attach.formPerm], σ.IsCycle

case h2
α : Type u_1
inst✝ : DecidableEq α
l l' : List α
hl : l.attach.Nodup
hn : 2 ≤ l.attach.length
⊢ Pairwise Perm.Disjoint [l.attach.formPerm]
tactic: rw [cycleType_eq [l.attach.formPerm]]
Theorem: Set.encard_preimage_of_injective_subset_range
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : Function.Injective f
ht : t ⊆ range f
⊢ (f ⁻¹' t).encard = t.encard
state_after: no goals
tactic: rw [← hf.encard_image, image_preimage_eq_inter_range, inter_eq_self_of_subset_left ht]
Theorem: Fin.lt_castPred_succ
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a : Fin (n + 1)
ha : a.succ ≠ last (n + 1)
⊢ a < a.succ.castPred ha
state_after: no goals
tactic: rw [lt_castPred_succ_iff, le_def]
Theorem: Matrix.fromRows_mul_fromColumns
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
B₁ : Matrix n n₁ R
B₂ : Matrix n n₂ R
⊢ A₁.fromRows A₂ * B₁.fromColumns B₂ = fromBlocks (A₁ * B₁) (A₁ * B₂) (A₂ * B₁) (A₂ * B₂)
state_after: no goals
tactic: ext (_ | _) (_ | _) <;> simp
Theorem: IsCompact.vadd_set
File: Mathlib/Topology/Algebra/MulAction.lean

Proof steps:
state_before: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁴ : TopologicalSpace M
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : SMul M X
inst✝ : ContinuousSMul M X
f : Y → M
g : Y → X
b : Y
s : Set Y
k : Set M
u : Set X
hk : IsCompact k
hu : IsCompact u
⊢ IsCompact (k • u)
state_after: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁴ : TopologicalSpace M
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : SMul M X
inst✝ : ContinuousSMul M X
f : Y → M
g : Y → X
b : Y
s : Set Y
k : Set M
u : Set X
hk : IsCompact k
hu : IsCompact u
⊢ IsCompact ((fun x => x.1 • x.2) '' k ×ˢ u)
tactic: rw [← Set.image_smul_prod]
state_before: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁴ : TopologicalSpace M
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : SMul M X
inst✝ : ContinuousSMul M X
f : Y → M
g : Y → X
b : Y
s : Set Y
k : Set M
u : Set X
hk : IsCompact k
hu : IsCompact u
⊢ IsCompact ((fun x => x.1 • x.2) '' k ×ˢ u)
state_after: no goals
tactic: exact IsCompact.image (hk.prod hu) continuous_smul
Theorem: Option.map₂_left_comm
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c)
state_after: no goals
tactic: cases a <;> cases b <;> cases c <;> simp [h_left_comm]
Theorem: lt_add_neg_iff_add_lt
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ c * b < a * b⁻¹ * b ↔ c * b < a
state_after: no goals
tactic: rw [inv_mul_cancel_right]
Theorem: ArithmeticFunction.natCoe_mul
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f g : ArithmeticFunction ℕ
⊢ ↑(f * g) = ↑f * ↑g
state_after: case h
R : Type u_1
inst✝ : Semiring R
f g : ArithmeticFunction ℕ
n : ℕ
⊢ ↑(f * g) n = (↑f * ↑g) n
tactic: ext n
state_before: case h
R : Type u_1
inst✝ : Semiring R
f g : ArithmeticFunction ℕ
n : ℕ
⊢ ↑(f * g) n = (↑f * ↑g) n
state_after: no goals
tactic: simp
Theorem: List.mem_orderedInsert
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
⊢ a ∈ orderedInsert r b [] ↔ a = b ∨ a ∈ []
state_after: no goals
tactic: simp [orderedInsert]
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
x : α
xs : List α
⊢ a ∈ orderedInsert r b (x :: xs) ↔ a = b ∨ a ∈ x :: xs
state_after: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
x : α
xs : List α
⊢ (a ∈ if r b x then b :: x :: xs else x :: orderedInsert r b xs) ↔ a = b ∨ a ∈ x :: xs
tactic: rw [orderedInsert]
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
x : α
xs : List α
⊢ (a ∈ if r b x then b :: x :: xs else x :: orderedInsert r b xs) ↔ a = b ∨ a ∈ x :: xs
state_after: case pos
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
x : α
xs : List α
h✝ : r b x
⊢ a ∈ b :: x :: xs ↔ a = b ∨ a ∈ x :: xs

case neg
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
x : α
xs : List α
h✝ : ¬r b x
⊢ a ∈ x :: orderedInsert r b xs ↔ a = b ∨ a ∈ x :: xs
tactic: split_ifs
Theorem: AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_ge_nat
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

Proof steps:
state_before: f : ℝ → ℝ
b : ℝ
hb : b ∈ Set.Ioo 0 1
hf : GrowsPolynomially f
⊢ ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, c * f ↑n ≤ f u
state_after: case intro.intro
f : ℝ → ℝ
b : ℝ
hb : b ∈ Set.Ioo 0 1
hf : GrowsPolynomially f
c : ℝ
hc_mem : c > 0
hc : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, c * f x ≤ f u
⊢ ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, c * f ↑n ≤ f u
tactic: obtain ⟨c, hc_mem, hc⟩ := hf.eventually_atTop_ge hb
state_before: case intro.intro
f : ℝ → ℝ
b : ℝ
hb : b ∈ Set.Ioo 0 1
hf : GrowsPolynomially f
c : ℝ
hc_mem : c > 0
hc : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, c * f x ≤ f u
⊢ ∃ c > 0, ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (b * ↑n) ↑n, c * f ↑n ≤ f u
state_after: no goals
tactic: exact ⟨c, hc_mem, hc.natCast_atTop⟩
Theorem: ProbabilityTheory.indepFun_iff_indepSet_preimage
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β✝ : Type u_3
γ✝ : Type u_4
κ : ι → Type u_5
β : Type u_6
β' : Type u_7
γ : Type u_8
γ' : Type u_9
_mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → β
g : Ω → β'
mβ : MeasurableSpace β
mβ' : MeasurableSpace β'
inst✝ : IsProbabilityMeasure μ
hf : Measurable f
hg : Measurable g
⊢ IndepFun f g μ ↔ ∀ (s : Set β) (t : Set β'), MeasurableSet s → MeasurableSet t → IndepSet (f ⁻¹' s) (g ⁻¹' t) μ
state_after: no goals
tactic: simp only [IndepFun, IndepSet, Kernel.indepFun_iff_indepSet_preimage hf hg, ae_dirac_eq,
    Filter.eventually_pure, Kernel.const_apply]
Theorem: Submodule.map_smul
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V
a : K
h : a ≠ 0
⊢ map (a • f) p ≤ map f p
state_after: no goals
tactic: rw [map_le_iff_le_comap, comap_smul f _ a h, ← map_le_iff_le_comap]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V
a : K
h : a ≠ 0
⊢ map f p ≤ map (a • f) p
state_after: no goals
tactic: rw [map_le_iff_le_comap, ← comap_smul f _ a h, ← map_le_iff_le_comap]
Theorem: Set.MapsTo.exists_equiv_extend_of_card_eq
File: Mathlib/Data/Fintype/Sum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Fintype α
t : Finset β
hαt : Fintype.card α = t.card
s : Set α
f : α → β
hfst : MapsTo f s ↑t
hfs : InjOn f s
⊢ ∃ g, ∀ i ∈ s, ↑(g i) = f i
state_after: no goals
tactic: classical
    let s' : Finset α := s.toFinset
    have hfst' : s'.image f ⊆ t := by simpa [s', ← Finset.coe_subset] using hfst
    have hfs' : Set.InjOn f s' := by simpa [s'] using hfs
    obtain ⟨g, hg⟩ := Finset.exists_equiv_extend_of_card_eq hαt hfst' hfs'
    refine ⟨g, fun i hi => ?_⟩
    apply hg
    simpa [s'] using hi
Theorem: Encodable.iSup_decode₂
File: Mathlib/Logic/Encodable/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable β
inst✝ : CompleteLattice α
f : β → α
⊢ ⨆ i, ⨆ b ∈ decode₂ β i, f b = ⨆ b, f b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Encodable β
inst✝ : CompleteLattice α
f : β → α
⊢ ⨆ j, ⨆ i, ⨆ (_ : j ∈ decode₂ β i), f j = ⨆ b, f b
tactic: rw [iSup_comm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable β
inst✝ : CompleteLattice α
f : β → α
⊢ ⨆ j, ⨆ i, ⨆ (_ : j ∈ decode₂ β i), f j = ⨆ b, f b
state_after: no goals
tactic: simp only [mem_decode₂, iSup_iSup_eq_right]
Theorem: NNReal.iSup_mul
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ (⨆ i, f i) * a = ⨆ i, f i * a
state_after: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ ⨆ i, a * f i = ⨆ i, f i * a
tactic: rw [mul_comm, mul_iSup]
state_before: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ ⨆ i, a * f i = ⨆ i, f i * a
state_after: no goals
tactic: simp_rw [mul_comm]