tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.L2.smul_left'
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: rw [inner_def, inner_def, ← smul_eq_mul, ← integral_smul]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.103781
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : { x // x ∈ Lp E 2 }
r : 𝕜
⊢ inner (r • f) g = ↑(starRingEnd 𝕜) r * inner f g

tactic: refine' integral_congr_ae ((coeFn_smul r f).mono fun x hx => _)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.103781
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : { x // x ∈ Lp E 2 }
r : 𝕜
⊢ (∫ (a : α), inner (↑↑(r • f) a) (↑↑g a) ∂μ) = ∫ (a : α), ↑(starRingEnd 𝕜) r • inner (↑↑f a) (↑↑g a) ∂μ

tactic: simp only
state_before: α : Type u_1
E : Type u_2
F : Type ?u.103781
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : { x // x ∈ Lp E 2 }
r : 𝕜
x : α
hx : ↑↑(r • f) x = (r • ↑↑f) x
⊢ (fun a => inner (↑↑(r • f) a) (↑↑g a)) x = (fun a => ↑(starRingEnd 𝕜) r • inner (↑↑f a) (↑↑g a)) x

tactic: rw [smul_eq_mul, ← inner_smul_left, hx, Pi.smul_apply]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.103781
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : { x // x ∈ Lp E 2 }
r : 𝕜
x : α
hx : ↑↑(r • f) x = (r • ↑↑f) x
⊢ inner (↑↑(r • f) x) (↑↑g x) = ↑(starRingEnd 𝕜) r • inner (↑↑f x) (↑↑g x)
Theorem: Real.arcsin_eq_pi_div_two_sub_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos]
state_before: x : ℝ
⊢ arcsin x = π / 2 - arccos x
Theorem: Ordinal.CNFRec_zero
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: rw [CNFRec, dif_pos rfl]
state_before: C : Ordinal → Sort u_2
b : Ordinal
H0 : C 0
H : (o : Ordinal) → o ≠ 0 → C (o % b ^ log b o) → C o
⊢ CNFRec b H0 H 0 = H0

tactic: rfl
state_before: C : Ordinal → Sort u_2
b : Ordinal
H0 : C 0
H : (o : Ordinal) → o ≠ 0 → C (o % b ^ log b o) → C o
⊢ Eq.mpr (_ : C 0 = C 0) H0 = H0
Theorem: Int.subNatNat_of_sub_eq_succ
File: Std/Data/Int/Lemmas.lean

tactic: rw [subNatNat, h]
state_before: m n k : Nat
h : n - m = succ k
⊢ subNatNat m n = -[k+1]
Theorem: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_hom_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [limitUncurryIsoLimitCompLim, IsLimit.conePointUniqueUpToIso, IsLimit.uniqueUpToIso]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k = limit.π (uncurry.obj F) (j, k)

tactic: simp
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ limit.lift (F ⋙ lim) (coneOfConeUncurry (fun j => limit.isLimit (F.obj j)) (limit.cone (uncurry.obj F))) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (uncurry.obj F) (j, k)
Theorem: AddCircle.norm_eq_of_zero
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: suffices { y : ℝ | (y : AddCircle (0 : ℝ)) = (x : AddCircle (0 : ℝ)) } = {x} by
  rw [quotient_norm_eq, this, image_singleton, Real.norm_eq_abs, csInf_singleton]
state_before: p x : ℝ
⊢ ‖↑x‖ = abs x

tactic: ext y
state_before: p x : ℝ
⊢ {y | ↑y = ↑x} = {x}

tactic: simp [QuotientAddGroup.eq_iff_sub_mem, mem_zmultiples_iff, sub_eq_zero]
state_before: case h
p x y : ℝ
⊢ y ∈ {y | ↑y = ↑x} ↔ y ∈ {x}

tactic: rw [quotient_norm_eq, this, image_singleton, Real.norm_eq_abs, csInf_singleton]
state_before: p x : ℝ
this : {y | ↑y = ↑x} = {x}
⊢ ‖↑x‖ = abs x
Theorem: surjOn_Ioo_of_monotone_surjective
File: Mathlib/Data/Set/Intervals/SurjOn.lean

tactic: intro p hp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
⊢ SurjOn f (Ioo a b) (Ioo (f a) (f b))

tactic: rcases h_surj p with ⟨x, rfl⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
p : β
hp : p ∈ Ioo (f a) (f b)
⊢ p ∈ f '' Ioo a b

tactic: refine' ⟨x, mem_Ioo.2 _, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : f x ∈ Ioo (f a) (f b)
⊢ f x ∈ f '' Ioo a b

tactic: contrapose! hp
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : f x ∈ Ioo (f a) (f b)
⊢ a < x ∧ x < b

tactic: exact fun h => h.2.not_le (h_mono <| hp <| h_mono.reflect_lt h.1)
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : a < x → b ≤ x
⊢ ¬f x ∈ Ioo (f a) (f b)
Theorem: Int.clog_natCast
File: Mathlib/Data/Int/Log.lean

tactic: cases' n with n
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b n : ℕ
⊢ clog b ↑n = ↑(Nat.clog b n)

tactic: simp [clog_of_right_le_one]
state_before: case zero
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
⊢ clog b ↑Nat.zero = ↑(Nat.clog b Nat.zero)

tactic: rw [clog_of_one_le_right, (Nat.ceil_eq_iff (Nat.succ_ne_zero n)).mpr] <;> simp
state_before: case succ
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b n : ℕ
⊢ clog b ↑(Nat.succ n) = ↑(Nat.clog b (Nat.succ n))
Theorem: padicNormE.norm_int_le_pow_iff_dvd
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have : (p : ℝ) ^ (-n : ℤ) = (p : ℚ) ^ (-n : ℤ) := by simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
⊢ ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑(p ^ n) ∣ k

tactic: rw [show (k : ℚ_[p]) = ((k : ℚ) : ℚ_[p]) by norm_cast, eq_padicNorm, this]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
this : ↑p ^ (-↑n) = ↑(↑p ^ (-↑n))
⊢ ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑(p ^ n) ∣ k

tactic: norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
this : ↑p ^ (-↑n) = ↑(↑p ^ (-↑n))
⊢ ↑(padicNorm p ↑k) ≤ ↑(↑p ^ (-↑n)) ↔ ↑(p ^ n) ∣ k

tactic: rw [← padicNorm.dvd_iff_norm_le]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
this : ↑p ^ (-↑n) = ↑(↑p ^ (-↑n))
⊢ padicNorm p ↑k ≤ ↑p ^ (-↑n) ↔ ↑(p ^ n) ∣ k

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
⊢ ↑p ^ (-↑n) = ↑(↑p ^ (-↑n))

tactic: norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℤ
n : ℕ
this : ↑p ^ (-↑n) = ↑(↑p ^ (-↑n))
⊢ ↑k = ↑↑k
Theorem: CategoryTheory.Functor.map_inv_hom
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ F.map (inv f) ≫ F.map f = 𝟙 (F.obj Y)
Theorem: Continuous.continuous_symm_of_equiv_compact_to_t2
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [continuous_iff_isClosed]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.104526
δ : Type ?u.104529
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CompactSpace α
inst✝ : T2Space β
f : α ≃ β
hf : Continuous ↑f
⊢ Continuous ↑f.symm

tactic: intro C hC
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.104526
δ : Type ?u.104529
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CompactSpace α
inst✝ : T2Space β
f : α ≃ β
hf : Continuous ↑f
⊢ ∀ (s : Set α), IsClosed s → IsClosed (↑f.symm ⁻¹' s)

tactic: have hC' : IsClosed (f '' C) := (hC.isCompact.image hf).isClosed
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.104526
δ : Type ?u.104529
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CompactSpace α
inst✝ : T2Space β
f : α ≃ β
hf : Continuous ↑f
C : Set α
hC : IsClosed C
⊢ IsClosed (↑f.symm ⁻¹' C)

tactic: rwa [Equiv.image_eq_preimage] at hC'
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.104526
δ : Type ?u.104529
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CompactSpace α
inst✝ : T2Space β
f : α ≃ β
hf : Continuous ↑f
C : Set α
hC : IsClosed C
hC' : IsClosed (↑f '' C)
⊢ IsClosed (↑f.symm ⁻¹' C)
Theorem: Nat.leRecOn_surjective
File: Mathlib/Data/Nat/Basic.lean

tactic: induction' hnm with m hnm ih
state_before: m✝ n✝ k : ℕ
C : ℕ → Sort u
n m : ℕ
hnm : n ≤ m
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
⊢ Function.Surjective (leRecOn hnm fun {k} => next)

tactic: intro x
state_before: case step
m✝¹ n✝ k : ℕ
C : ℕ → Sort u
n m✝ : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
m : ℕ
hnm : Nat.le n m
ih : Function.Surjective (leRecOn hnm fun {k} => next)
⊢ Function.Surjective (leRecOn (_ : Nat.le n (succ m)) fun {k} => next)

tactic: rcases Hnext _ x with ⟨w, rfl⟩
state_before: case step
m✝¹ n✝ k : ℕ
C : ℕ → Sort u
n m✝ : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
m : ℕ
hnm : Nat.le n m
ih : Function.Surjective (leRecOn hnm fun {k} => next)
x : C (succ m)
⊢ ∃ a, leRecOn (_ : Nat.le n (succ m)) (fun {k} => next) a = x

tactic: rcases ih w with ⟨x, rfl⟩
state_before: case step.intro
m✝¹ n✝ k : ℕ
C : ℕ → Sort u
n m✝ : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
m : ℕ
hnm : Nat.le n m
ih : Function.Surjective (leRecOn hnm fun {k} => next)
w : C m
⊢ ∃ a, leRecOn (_ : Nat.le n (succ m)) (fun {k} => next) a = next w

tactic: use x
state_before: case step.intro.intro
m✝¹ n✝ k : ℕ
C : ℕ → Sort u
n m✝ : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
m : ℕ
hnm : Nat.le n m
ih : Function.Surjective (leRecOn hnm fun {k} => next)
x : C n
⊢ ∃ a, leRecOn (_ : Nat.le n (succ m)) (fun {k} => next) a = next (leRecOn hnm (fun {k} => next) x)

tactic: rw [leRecOn_succ]
state_before: case step.intro.intro
m✝¹ n✝ k : ℕ
C : ℕ → Sort u
n m✝ : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
m : ℕ
hnm : Nat.le n m
ih : Function.Surjective (leRecOn hnm fun {k} => next)
x : C n
⊢ leRecOn (_ : Nat.le n (succ m)) (fun {k} => next) x = next (leRecOn hnm (fun {k} => next) x)

tactic: intro x
state_before: case refl
m✝ n✝ k : ℕ
C : ℕ → Sort u
n m : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
⊢ Function.Surjective (leRecOn (_ : Nat.le n n) fun {k} => next)

tactic: use x
state_before: case refl
m✝ n✝ k : ℕ
C : ℕ → Sort u
n m : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
x : C n
⊢ ∃ a, leRecOn (_ : Nat.le n n) (fun {k} => next) a = x

tactic: rw [leRecOn_self]
state_before: case refl
m✝ n✝ k : ℕ
C : ℕ → Sort u
n m : ℕ
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Function.Surjective next
x : C n
⊢ leRecOn (_ : Nat.le n n) (fun {k} => next) x = x
Theorem: Pell.y_mul_dvd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [Nat.mul_succ, yn_add]
state_before: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ yn a1 (n * (k + 1))

tactic: exact dvd_add (dvd_mul_left _ _) ((y_mul_dvd _ k).mul_right _)
state_before: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ xn a1 (n * k) * yn a1 n + yn a1 (n * k) * xn a1 n
Theorem: Finset.subtype_map
File: Mathlib/Data/Finset/Image.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.130155
γ : Type ?u.130158
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ map (Embedding.subtype p) (Finset.subtype p s) = filter p s

tactic: simp [@and_comm _ (_ = _), @and_left_comm _ (_ = _), @and_comm (p x) (x ∈ s)]
state_before: case a
α : Type u_1
β : Type ?u.130155
γ : Type ?u.130158
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
x : α
⊢ x ∈ map (Embedding.subtype p) (Finset.subtype p s) ↔ x ∈ filter p s
Theorem: Polynomial.prod_multiset_root_eq_finset_root
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp only [count_roots, Finset.prod_multiset_map_count]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p)) =
    Finset.prod (Multiset.toFinset (roots p)) fun a => (X - ↑C a) ^ rootMultiplicity a p
Theorem: inv_eq_one_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, one_mul]
state_before: α : Type ?u.17881
β : Type ?u.17884
G : Type u_1
inst✝ : DivInvMonoid G
a b c x : G
⊢ x⁻¹ = 1 / x
Theorem: StructureGroupoid.LocalInvariantProp.liftPropOn_indep_chart
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: convert((hG.liftPropWithinAt_indep_chart he (e.symm_mapsTo hy.1) hf hy.2.2).1 (h _ hy.2.1)).2
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.31197
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : TopologicalSpace H'
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
inst✝¹ : HasGroupoid M G
inst✝ : HasGroupoid M' G'
he : e ∈ maximalAtlas M G
hf : f ∈ maximalAtlas M' G'
h : LiftPropOn P g s
y : H
hy : y ∈ e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (s ∩ g ⁻¹' f.source)
⊢ P (↑f ∘ g ∘ ↑(LocalHomeomorph.symm e)) (↑(LocalHomeomorph.symm e) ⁻¹' s) y

tactic: rw [e.right_inv hy.1]
state_before: case h.e'_3
H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.31197
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : TopologicalSpace H'
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
inst✝¹ : HasGroupoid M G
inst✝ : HasGroupoid M' G'
he : e ∈ maximalAtlas M G
hf : f ∈ maximalAtlas M' G'
h : LiftPropOn P g s
y : H
hy : y ∈ e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (s ∩ g ⁻¹' f.source)
⊢ y = ↑e (↑(LocalHomeomorph.symm e) y)
Theorem: Multiset.prod_singleton
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simp only [mul_one, prod_cons, ← cons_zero, eq_self_iff_true, prod_zero]
state_before: ι : Type ?u.11541
α : Type u_1
β : Type ?u.11547
γ : Type ?u.11550
inst✝ : CommMonoid α
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
a : α
⊢ prod {a} = a
Theorem: EuclideanSpace.inner_single_right
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simp [apply_ite conj, mul_comm]
state_before: ι : Type u_1
ι' : Type ?u.652079
𝕜 : Type u_2
inst✝¹⁰ : IsROrC 𝕜
E : Type ?u.652088
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.652108
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.652126
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.652146
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
i : ι
a : 𝕜
v : EuclideanSpace 𝕜 ι
⊢ inner v (single i a) = a * ↑(starRingEnd ((fun x => 𝕜) i)) (v i)
Theorem: Nat.add_div_right
File: Std/Data/Nat/Lemmas.lean

tactic: rw [div_eq_sub_div H (Nat.le_add_left _ _), Nat.add_sub_cancel]
state_before: x z : Nat
H : 0 < z
⊢ (x + z) / z = succ (x / z)
Theorem: PrimrecPred.and
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.132958
γ : Type ?u.132961
δ : Type ?u.132964
σ : Type ?u.132967
inst✝⁶ : Primcodable α
inst✝⁵ : Primcodable β
inst✝⁴ : Primcodable γ
inst✝³ : Primcodable δ
inst✝² : Primcodable σ
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
hp : PrimrecPred p
hq : PrimrecPred q
n : α
⊢ (decide (p n) && decide (q n)) = decide ((fun a => p a ∧ q a) n)
Theorem: Std.RBNode.Path.insert_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: simp [insert]
state_before: α : Type u_1
t : RBNode α
v : α
p : Path α
⊢ toList (insert p t v) = withList p (toList (setRoot v t))

tactic: split <;> simp [setRoot]
state_before: α : Type u_1
t : RBNode α
v : α
p : Path α
⊢ toList
      (match t with
      | nil => insertNew p v
      | node c a v_1 b => fill p (node c a v b)) =
    listL p ++ (toList (setRoot v t) ++ listR p)
Theorem: selfZpow_zero
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: simp [selfZpow_of_nonneg _ _ le_rfl]
state_before: R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
⊢ selfZpow x B 0 = 1
Theorem: Set.preimage_mul_preimage_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rintro _ ⟨_, _, _, _, rfl⟩
state_before: F : Type u_3
α : Type u_2
β : Type u_1
γ : Type ?u.154622
inst✝² : Mul α
inst✝¹ : Mul β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
⊢ ↑m ⁻¹' s * ↑m ⁻¹' t ⊆ ↑m ⁻¹' (s * t)

tactic: exact ⟨_, _, ‹_›, ‹_›, (map_mul m _ _).symm⟩
state_before: case intro.intro.intro.intro
F : Type u_3
α : Type u_2
β : Type u_1
γ : Type ?u.154622
inst✝² : Mul α
inst✝¹ : Mul β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
w✝¹ w✝ : α
left✝¹ : w✝¹ ∈ ↑m ⁻¹' s
left✝ : w✝ ∈ ↑m ⁻¹' t
⊢ (fun x x_1 => x * x_1) w✝¹ w✝ ∈ ↑m ⁻¹' (s * t)
Theorem: Set.prod_eq_iff_eq
File: Mathlib/Data/Set/Prod.lean

tactic: simp_rw [prod_eq_prod_iff, ht.ne_empty, and_true_iff, or_iff_left_iff_imp,
  or_false_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.90755
δ : Type ?u.90758
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : Set.Nonempty t
⊢ s ×ˢ t = s₁ ×ˢ t ↔ s = s₁

tactic: rintro ⟨rfl, rfl⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.90755
δ : Type ?u.90758
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : Set.Nonempty t
⊢ s = ∅ ∧ s₁ = ∅ → s = s₁

tactic: rfl
state_before: case intro
α : Type u_2
β : Type u_1
γ : Type ?u.90755
δ : Type ?u.90758
s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ht : Set.Nonempty t
⊢ ∅ = ∅
Theorem: catalan_succ'
File: Mathlib/Combinatorics/Catalan.lean

tactic: rw [catalan_succ, Nat.sum_antidiagonal_eq_sum_range_succ (fun x y => catalan x * catalan y) n,
  sum_range]
state_before: n : ℕ
⊢ catalan (n + 1) = ∑ ij in Nat.antidiagonal n, catalan ij.fst * catalan ij.snd
Theorem: LipschitzWith.norm_compLp_le
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simpa using hg.norm_compLp_sub_le g0 f 0
state_before: α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2588935
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
f : { x // x ∈ Lp E p }
⊢ ‖compLp hg g0 f‖ ≤ ↑c * ‖f‖
Theorem: IsCoprime.mul_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [isCoprime_comm] at H1 H2⊢
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x y
H2 : IsCoprime x z
⊢ IsCoprime x (y * z)

tactic: exact H1.mul_left H2
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime y x
H2 : IsCoprime z x
⊢ IsCoprime (y * z) x
Theorem: MeasureTheory.tendsto_integral_approxOn_of_measurable
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: have hfi' := SimpleFunc.integrable_approxOn hfm hfi h₀ h₀i
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1273109
𝕜 : Type ?u.1273112
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1275803
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
s : Set E
inst✝ : SeparableSpace ↑s
hfi : Integrable f
hfm : Measurable f
hs : ∀ᵐ (x : α) ∂μ, f x ∈ closure s
y₀ : E
h₀ : y₀ ∈ s
h₀i : Integrable fun x => y₀
⊢ Tendsto (fun n => SimpleFunc.integral μ (approxOn f hfm s y₀ h₀ n)) atTop (𝓝 (∫ (x : α), f x ∂μ))

tactic: simp only [SimpleFunc.integral_eq_integral _ (hfi' _), integral, L1.integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1273109
𝕜 : Type ?u.1273112
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1275803
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
s : Set E
inst✝ : SeparableSpace ↑s
hfi : Integrable f
hfm : Measurable f
hs : ∀ᵐ (x : α) ∂μ, f x ∈ closure s
y₀ : E
h₀ : y₀ ∈ s
h₀i : Integrable fun x => y₀
hfi' : ∀ (n : ℕ), Integrable ↑(approxOn f hfm s y₀ h₀ n)
⊢ Tendsto (fun n => SimpleFunc.integral μ (approxOn f hfm s y₀ h₀ n)) atTop (𝓝 (∫ (x : α), f x ∂μ))

tactic: exact tendsto_setToFun_approxOn_of_measurable (dominatedFinMeasAdditive_weightedSMul μ)
  hfi hfm hs h₀ h₀i
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1273109
𝕜 : Type ?u.1273112
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1275803
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
s : Set E
inst✝ : SeparableSpace ↑s
hfi : Integrable f
hfm : Measurable f
hs : ∀ᵐ (x : α) ∂μ, f x ∈ closure s
y₀ : E
h₀ : y₀ ∈ s
h₀i : Integrable fun x => y₀
hfi' : ∀ (n : ℕ), Integrable ↑(approxOn f hfm s y₀ h₀ n)
⊢ Tendsto
    (fun n =>
      if hf : Integrable fun x => ↑(approxOn f hfm s y₀ h₀ n) x then
        ↑L1.integralCLM (Integrable.toL1 (fun x => ↑(approxOn f hfm s y₀ h₀ n) x) hf)
      else 0)
    atTop (𝓝 (if hf : Integrable fun x => f x then ↑L1.integralCLM (Integrable.toL1 (fun x => f x) hf) else 0))
Theorem: FiniteDimensional.rank_lt_of_finrank_lt
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rwa [← Cardinal.toNat_lt_iff_lt_of_lt_aleph0, toNat_cast]
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : n < finrank K V
⊢ ↑n < Module.rank K V

tactic: exact nat_lt_aleph0 n
state_before: case hc
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : n < finrank K V
⊢ ↑n < ℵ₀

tactic: contrapose! h
state_before: case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : n < finrank K V
⊢ Module.rank K V < ℵ₀

tactic: rw [finrank, Cardinal.toNat_apply_of_aleph0_le h]
state_before: case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : ℵ₀ ≤ Module.rank K V
⊢ finrank K V ≤ n

tactic: exact n.zero_le
state_before: case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : ℵ₀ ≤ Module.rank K V
⊢ 0 ≤ n