tasksource/leandojo huggingface dataset:
Theorem: Subspace.isCompl_dualAnnihilator
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [isCompl_iff, disjoint_iff, codisjoint_iff] at h⊢
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W W' : Subspace K V₁
h : IsCompl W W'
⊢ IsCompl (dualAnnihilator W) (dualAnnihilator W')

tactic: rw [← dualAnnihilator_inf_eq, ← dualAnnihilator_sup_eq, h.1, h.2, dualAnnihilator_top,
  dualAnnihilator_bot]
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W W' : Subspace K V₁
h : W ⊓ W' = ⊥ ∧ W ⊔ W' = ⊤
⊢ dualAnnihilator W ⊓ dualAnnihilator W' = ⊥ ∧ dualAnnihilator W ⊔ dualAnnihilator W' = ⊤

tactic: exact ⟨rfl, rfl⟩
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W W' : Subspace K V₁
h : W ⊓ W' = ⊥ ∧ W ⊔ W' = ⊤
⊢ ⊥ = ⊥ ∧ ⊤ = ⊤
Theorem: inv_neg_one
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← neg_inv, inv_one]
state_before: α : Type ?u.37165
β : Type ?u.37168
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a b : K
⊢ (-1)⁻¹ = -1
Theorem: tendstoUniformlyOn_iff_tendstoUniformlyOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp only [TendstoUniformlyOn, TendstoUniformlyOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ TendstoUniformlyOn F f p s ↔ TendstoUniformlyOnFilter F f p (𝓟 s)

tactic: apply forall₂_congr
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ s → (f x, F n x) ∈ u) ↔
    ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.snd, F n.fst n.snd) ∈ u

tactic: simp_rw [eventually_prod_principal_iff]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ ∀ (a : Set (β × β)),
    a ∈ 𝓤 β →
      ((∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ s → (f x, F n x) ∈ a) ↔
        ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.snd, F n.fst n.snd) ∈ a)

tactic: simp
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ ∀ (a : Set (β × β)), a ∈ 𝓤 β → True
Theorem: smul_mem_nhds
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rcases mem_nhds_iff.1 ht with ⟨u, ut, u_open, hu⟩
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
a : α
x : β
ht : t ∈ 𝓝 x
⊢ a • t ∈ 𝓝 (a • x)

tactic: exact mem_nhds_iff.2 ⟨a • u, smul_set_mono ut, u_open.smul a, smul_mem_smul_set hu⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
a : α
x : β
ht : t ∈ 𝓝 x
u : Set β
ut : u ⊆ t
u_open : IsOpen u
hu : x ∈ u
⊢ a • t ∈ 𝓝 (a • x)
Theorem: Nat.sub_eq_sub_min
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.min_def]
state_before: n m : Nat
⊢ n - m = n - min n m

tactic: split
state_before: n m : Nat
⊢ n - m = n - if n ≤ m then n else m

tactic: rw [Nat.sub_eq_zero_of_le ‹n ≤ m›, Nat.sub_self]
state_before: case inl
n m : Nat
h✝ : n ≤ m
⊢ n - m = n - n

tactic: rfl
state_before: case inr
n m : Nat
h✝ : ¬n ≤ m
⊢ n - m = n - m
Theorem: Matrix.toLinearMap₂_basisFun
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: ext M
state_before: R : Type u_1
R₁ : Type ?u.1404273
R₂ : Type ?u.1404276
M : Type ?u.1404279
M₁ : Type ?u.1404282
M₂ : Type ?u.1404285
M₁' : Type ?u.1404288
M₂' : Type ?u.1404291
n : Type u_2
m : Type u_3
n' : Type ?u.1404300
m' : Type ?u.1404303
ι : Type ?u.1404306
inst✝⁸ : CommRing R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
⊢ toLinearMap₂ (Pi.basisFun R n) (Pi.basisFun R m) = toLinearMap₂'

tactic: simp only [Matrix.toLinearMap₂_apply, Matrix.toLinearMap₂'_apply, Pi.basisFun_repr, coe_comp,
  Function.comp_apply]
state_before: case h.h.h.h.h
R : Type u_1
R₁ : Type ?u.1404273
R₂ : Type ?u.1404276
M✝ : Type ?u.1404279
M₁ : Type ?u.1404282
M₂ : Type ?u.1404285
M₁' : Type ?u.1404288
M₂' : Type ?u.1404291
n : Type u_2
m : Type u_3
n' : Type ?u.1404300
m' : Type ?u.1404303
ι : Type ?u.1404306
inst✝⁸ : CommRing R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
M : Matrix n m R
i✝¹ : n
i✝ : m
⊢ ↑(comp (↑(comp (↑(toLinearMap₂ (Pi.basisFun R n) (Pi.basisFun R m)) M) (single i✝¹)) 1) (single i✝)) 1 =
    ↑(comp (↑(comp (↑toLinearMap₂' M) (single i✝¹)) 1) (single i✝)) 1
Theorem: Set.einfsep_insert_le
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [le_iInf_iff]
state_before: α : Type u_1
β : Type ?u.24010
inst✝ : EDist α
x y : α
s t : Set α
⊢ einfsep (insert x s) ≤ ⨅ (y : α) (_ : y ∈ s) (_ : x ≠ y), edist x y

tactic: refine' fun _ hy hxy => einfsep_le_edist_of_mem (mem_insert _ _) (mem_insert_of_mem _ hy) hxy
state_before: α : Type u_1
β : Type ?u.24010
inst✝ : EDist α
x y : α
s t : Set α
⊢ ∀ (i : α), i ∈ s → x ≠ i → einfsep (insert x s) ≤ edist x i
Theorem: Filter.HasBasis.mem_uniformity_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp only [Prod.forall, subset_def]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.93034
inst✝ : UniformSpace α
p : β → Prop
s : β → Set (α × α)
h : HasBasis (𝓤 α) p s
t : Set (α × α)
⊢ (∃ i, p i ∧ s i ⊆ t) ↔ ∃ i, p i ∧ ∀ (a b : α), (a, b) ∈ s i → (a, b) ∈ t
Theorem: Asymptotics.isBigO_iff_isBoundedUnder_le_div
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [isBigO_iff, IsBoundedUnder, IsBounded, eventually_map]
state_before: α : Type u_1
β : Type ?u.313491
E : Type u_3
F : Type ?u.313497
G : Type ?u.313500
E' : Type ?u.313503
F' : Type ?u.313506
G' : Type ?u.313509
E'' : Type ?u.313512
F'' : Type u_2
G'' : Type ?u.313518
R : Type ?u.313521
R' : Type ?u.313524
𝕜 : Type ?u.313527
𝕜' : Type ?u.313530
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
h : ∀ᶠ (x : α) in l, g'' x ≠ 0
⊢ f =O[l] g'' ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖ / ‖g'' x‖

tactic: exact
  exists_congr fun c =>
    eventually_congr <| h.mono fun x hx => (div_le_iff <| norm_pos_iff.2 hx).symm
state_before: α : Type u_1
β : Type ?u.313491
E : Type u_3
F : Type ?u.313497
G : Type ?u.313500
E' : Type ?u.313503
F' : Type ?u.313506
G' : Type ?u.313509
E'' : Type ?u.313512
F'' : Type u_2
G'' : Type ?u.313518
R : Type ?u.313521
R' : Type ?u.313524
𝕜 : Type ?u.313527
𝕜' : Type ?u.313530
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
h : ∀ᶠ (x : α) in l, g'' x ≠ 0
⊢ (∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g'' x‖) ↔ ∃ b, ∀ᶠ (a : α) in l, ‖f a‖ / ‖g'' a‖ ≤ b
Theorem: Real.arcsin_sin'
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [sin_arcsin (neg_one_le_sin _) (sin_le_one _)]
state_before: x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ sin (arcsin (sin x)) = sin x
Theorem: Set.image_const_mul_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using image_mul_const_uIcc a b c
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
⊢ (fun x => a * x) '' [[b, c]] = [[a * b, a * c]]
Theorem: List.pairwise_and_iff
File: Mathlib/Data/List/Pairwise.lean

tactic: induction' hR with a l R1 R2 IH <;> simp only [Pairwise.nil, pairwise_cons] at *
state_before: α : Type u_1
β : Type ?u.2465
R S T : α → α → Prop
a : α
l : List α
x✝ : Pairwise R l ∧ Pairwise S l
hR : Pairwise R l
hS : Pairwise S l
⊢ Pairwise (fun a b => R a b ∧ S a b) l

tactic: exact ⟨fun b bl => ⟨R1 b bl, hS.1 b bl⟩, IH ⟨R2, hS.2⟩ hS.2⟩
state_before: case cons
α : Type u_1
β : Type ?u.2465
R S T : α → α → Prop
a✝ : α
l✝ : List α
x✝¹ : Pairwise R l✝ ∧ Pairwise S l✝
hS✝ : Pairwise S l✝
a : α
l : List α
R1 : ∀ (a' : α), a' ∈ l → R a a'
R2 : Pairwise R l
IH : Pairwise R l ∧ Pairwise S l → Pairwise S l → Pairwise (fun a b => R a b ∧ S a b) l
x✝ : ((∀ (a' : α), a' ∈ l → R a a') ∧ Pairwise R l) ∧ (∀ (a' : α), a' ∈ l → S a a') ∧ Pairwise S l
hS : (∀ (a' : α), a' ∈ l → S a a') ∧ Pairwise S l
⊢ (∀ (a' : α), a' ∈ l → R a a' ∧ S a a') ∧ Pairwise (fun a b => R a b ∧ S a b) l
Theorem: affineSpan_insert_eq_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← mem_coe] at h
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.491936
p : P
ps : Set P
h : p ∈ affineSpan k ps
⊢ affineSpan k (insert p ps) = affineSpan k ps

tactic: rw [← affineSpan_insert_affineSpan, Set.insert_eq_of_mem h, affineSpan_coe]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.491936
p : P
ps : Set P
h : p ∈ ↑(affineSpan k ps)
⊢ affineSpan k (insert p ps) = affineSpan k ps
Theorem: mem_parallelepiped_iff
File: Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean

tactic: simp [parallelepiped, eq_comm]
state_before: ι : Type u_2
ι' : Type ?u.4165
E : Type u_1
F : Type ?u.4171
inst✝⁵ : Fintype ι
inst✝⁴ : Fintype ι'
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
inst✝¹ : AddCommGroup F
inst✝ : Module ℝ F
v : ι → E
x : E
⊢ x ∈ parallelepiped v ↔ ∃ t _ht, x = ∑ i : ι, t i • v i
Theorem: nhdsWithin_Iio_eq_bot_iff
File: Mathlib/Topology/Order/Basic.lean

tactic: convert (config := {preTransparency := .default})
  nhdsWithin_Ioi_eq_bot_iff (a := OrderDual.toDual a) using 4
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
⊢ 𝓝[Iio a] a = ⊥ ↔ IsBot a ∨ ∃ b, b ⋖ a

tactic: exact ofDual_covby_ofDual_iff
state_before: case h.e'_2.h.e'_2.h.e'_2.h.h.a
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
e_1✝ : α = (fun x => αᵒᵈ) a
x✝ : α
⊢ x✝ ⋖ a ↔ ↑toDual a ⋖ x✝
Theorem: Order.not_isPredLimit_iff_exists_covby
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp [IsPredLimit]
state_before: α : Type u_1
inst✝ : LT α
a✝ a : α
⊢ ¬IsPredLimit a ↔ ∃ b, a ⋖ b
Theorem: Sym2.eq_swap
File: Mathlib/Data/Sym/Sym2.lean

tactic: rw [Quotient.eq]
state_before: α : Type u_1
β : Type ?u.4046
γ : Type ?u.4049
a b : α
⊢ Quotient.mk (Rel.setoid α) (a, b) = Quotient.mk (Rel.setoid α) (b, a)

tactic: apply Rel.swap
state_before: α : Type u_1
β : Type ?u.4046
γ : Type ?u.4049
a b : α
⊢ (a, b) ≈ (b, a)
Theorem: DMatrix.map_sub
File: Mathlib/Data/Matrix/DMatrix.lean

tactic: ext
state_before: l : Type ?u.28777
m : Type u_1
n : Type u_2
o : Type ?u.28786
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddGroup (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddGroup (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
⊢ (map (M - N) fun i j => ↑f) = (map M fun i j => ↑f) - map N fun i j => ↑f

tactic: simp
state_before: case a
l : Type ?u.28777
m : Type u_1
n : Type u_2
o : Type ?u.28786
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddGroup (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddGroup (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
i✝ : m
j✝ : n
⊢ map (M - N) (fun i j => ↑f) i✝ j✝ = ((map M fun i j => ↑f) - map N fun i j => ↑f) i✝ j✝
Theorem: IsLeftRegular.pow_iff
File: Mathlib/Algebra/Regular/Pow.lean

tactic: refine' ⟨_, IsLeftRegular.pow n⟩
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n) ↔ IsLeftRegular a

tactic: rw [← Nat.succ_pred_eq_of_pos n0, pow_succ']
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n) → IsLeftRegular a

tactic: exact IsLeftRegular.of_mul
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ Nat.pred n * a) → IsLeftRegular a
Theorem: IsGroupHom.preimage
File: Mathlib/Deprecated/Subgroup.lean

tactic: refine' { .. } <;>
  simp (config := { contextual := true }) [hs.one_mem, hs.mul_mem, hs.inv_mem, hf.map_mul,
    hf.map_one, hf.map_inv, InvMemClass.inv_mem]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.90350
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsSubgroup s
⊢ IsSubgroup (f ⁻¹' s)
Theorem: Real.tendsto_logb_atTop_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [tendsto_atTop_atBot]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
⊢ Tendsto (logb b) atTop atBot

tactic: intro e
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
⊢ ∀ (b_1 : ℝ), ∃ i, ∀ (a : ℝ), i ≤ a → logb b a ≤ b_1

tactic: use 1 ⊔ b ^ e
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e : ℝ
⊢ ∃ i, ∀ (a : ℝ), i ≤ a → logb b a ≤ e

tactic: intro a
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e : ℝ
⊢ ∀ (a : ℝ), 1 ⊔ b ^ e ≤ a → logb b a ≤ e

tactic: simp only [and_imp, sup_le_iff]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e a : ℝ
⊢ 1 ⊔ b ^ e ≤ a → logb b a ≤ e

tactic: intro ha
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e a : ℝ
⊢ 1 ≤ a → b ^ e ≤ a → logb b a ≤ e

tactic: rw [logb_le_iff_le_rpow_of_base_lt_one b_pos b_lt_one]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e a : ℝ
ha : 1 ≤ a
⊢ b ^ e ≤ a → logb b a ≤ e

tactic: tauto
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e a : ℝ
ha : 1 ≤ a
⊢ b ^ e ≤ a → b ^ e ≤ a

b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e a : ℝ
ha : 1 ≤ a
⊢ 0 < a

tactic: exact lt_of_lt_of_le zero_lt_one ha
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
e a : ℝ
ha : 1 ≤ a
⊢ 0 < a
Theorem: MeasureTheory.Measure.restrict_univ
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [hs]
state_before: α : Type u_1
β : Type ?u.293051
γ : Type ?u.293054
δ : Type ?u.293057
ι : Type ?u.293060
R : Type ?u.293063
R' : Type ?u.293066
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t s : Set α
hs : MeasurableSet s
⊢ ↑↑(restrict μ univ) s = ↑↑μ s
Theorem: mul_smul_one
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [← smul_eq_mul, ← smul_comm, smul_eq_mul, mul_one]
state_before: M✝ : Type ?u.27981
N✝ : Type ?u.27984
G : Type ?u.27987
A : Type ?u.27990
B : Type ?u.27993
α : Type ?u.27996
β : Type ?u.27999
γ : Type ?u.28002
δ : Type ?u.28005
M : Type u_1
N : Type u_2
inst✝² : MulOneClass N
inst✝¹ : SMul M N
inst✝ : SMulCommClass M N N
x : M
y : N
⊢ y * x • 1 = x • y
Theorem: Int.mul_nonpos_of_nonneg_of_nonpos
File: Std/Data/Int/Lemmas.lean

tactic: have h : a * b ≤ a * 0 := Int.mul_le_mul_of_nonneg_left hb ha
state_before: a b : Int
ha : 0 ≤ a
hb : b ≤ 0
⊢ a * b ≤ 0

tactic: rwa [Int.mul_zero] at h
state_before: a b : Int
ha : 0 ≤ a
hb : b ≤ 0
h : a * b ≤ a * 0
⊢ a * b ≤ 0
Theorem: Multiset.multinomial_filter_ne
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: dsimp only [multinomial]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
m : Multiset α
⊢ multinomial m = Nat.choose (↑card m) (count a m) * multinomial (filter ((fun x x_1 => x ≠ x_1) a) m)

tactic: convert Finsupp.multinomial_update a _
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
m : Multiset α
⊢ Finsupp.multinomial (↑toFinsupp m) =
    Nat.choose (↑card m) (count a m) * Finsupp.multinomial (↑toFinsupp (filter (fun x => a ≠ x) m))

tactic: rw [← Finsupp.card_toMultiset, m.toFinsupp_toMultiset]
state_before: case h.e'_3.h.e'_5.h.e'_1
α : Type u_1
inst✝ : DecidableEq α
a : α
m : Multiset α
⊢ ↑card m = Finsupp.sum (↑toFinsupp m) fun x => id

tactic: simp only [toFinsupp_apply]
state_before: case h.e'_3.h.e'_5.h.e'_2
α : Type u_1
inst✝ : DecidableEq α
a : α
m : Multiset α
⊢ count a m = ↑(↑toFinsupp m) a

tactic: ext1 a
state_before: case h.e'_3.h.e'_6.h.e'_2
α : Type u_1
inst✝ : DecidableEq α
a : α
m : Multiset α
⊢ ↑toFinsupp (filter (fun x => a ≠ x) m) = Finsupp.update (↑toFinsupp m) a 0

tactic: rw [toFinsupp_apply, count_filter, Finsupp.coe_update]
state_before: case h.e'_3.h.e'_6.h.e'_2.h
α : Type u_1
inst✝ : DecidableEq α
a✝ : α
m : Multiset α
a : α
⊢ ↑(↑toFinsupp (filter (fun x => a✝ ≠ x) m)) a = ↑(Finsupp.update (↑toFinsupp m) a✝ 0) a

tactic: split_ifs with h
state_before: case h.e'_3.h.e'_6.h.e'_2.h
α : Type u_1
inst✝ : DecidableEq α
a✝ : α
m : Multiset α
a : α
⊢ (if a✝ ≠ a then count a m else 0) = Function.update (↑(↑toFinsupp m)) a✝ 0 a

tactic: rw [Function.update_noteq h.symm, toFinsupp_apply]
state_before: case h.e'_3.h.e'_6.h.e'_2.h.inl
α : Type u_1
inst✝ : DecidableEq α
a✝ : α
m : Multiset α
a : α
h : a✝ ≠ a
⊢ count a m = Function.update (↑(↑toFinsupp m)) a✝ 0 a

tactic: rw [not_ne_iff.1 h, Function.update_same]
state_before: case h.e'_3.h.e'_6.h.e'_2.h.inr
α : Type u_1
inst✝ : DecidableEq α
a✝ : α
m : Multiset α
a : α
h : ¬a✝ ≠ a
⊢ 0 = Function.update (↑(↑toFinsupp m)) a✝ 0 a
Theorem: TopCat.isSheaf_of_isLimit
File: Mathlib/Topology/Sheaves/Limits.lean

tactic: let F' : J ⥤ Sheaf C X :=
  { obj := fun j => ⟨F.obj j, H j⟩
    map := fun f => ⟨F.map f⟩ }
state_before: C : Type u
inst✝² : Category C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), Presheaf.IsSheaf (F.obj j)
c : Cone F
hc : IsLimit c
⊢ Presheaf.IsSheaf c.pt

tactic: let e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents fun _ => Iso.refl _
state_before: C : Type u
inst✝² : Category C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), Presheaf.IsSheaf (F.obj j)
c : Cone F
hc : IsLimit c
F' : J ⥤ Sheaf C X :=
  CategoryTheory.Functor.mk
    { obj := fun j => { val := F.obj j, cond := (_ : Presheaf.IsSheaf (F.obj j)) },
      map := fun {X_1 Y} f => { val := F.map f } }
⊢ Presheaf.IsSheaf c.pt

tactic: exact Presheaf.isSheaf_of_iso
  ((isLimitOfPreserves (Sheaf.forget C X) (limit.isLimit F')).conePointsIsoOfNatIso hc e)
  (limit F').2
state_before: C : Type u
inst✝² : Category C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), Presheaf.IsSheaf (F.obj j)
c : Cone F
hc : IsLimit c
F' : J ⥤ Sheaf C X :=
  CategoryTheory.Functor.mk
    { obj := fun j => { val := F.obj j, cond := (_ : Presheaf.IsSheaf (F.obj j)) },
      map := fun {X_1 Y} f => { val := F.map f } }
e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents fun x => Iso.refl ((F' ⋙ Sheaf.forget C X).obj x)
⊢ Presheaf.IsSheaf c.pt
Theorem: Nat.leRecOn_succ'
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [leRecOn_succ (le_refl n), leRecOn_self]
state_before: m n✝ k : ℕ
C : ℕ → Sort u
n : ℕ
h : n ≤ n + 1
next : {k : ℕ} → C k → C (k + 1)
x : C n
⊢ leRecOn h (fun {k} => next) x = next x
Theorem: CategoryTheory.Arrow.inv_right
File: Mathlib/CategoryTheory/Arrow.lean

tactic: rw [← Comma.comp_right, IsIso.hom_inv_id, id_right]
state_before: T : Type u
inst✝¹ : Category T
f g : Arrow T
sq : f ⟶ g
inst✝ : IsIso sq
⊢ sq.right ≫ (inv sq).right = 𝟙 f.right
Theorem: Real.rpow_le_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← one_rpow z]
state_before: x✝ y z✝ x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1

tactic: exact rpow_le_rpow hx1 hx2 hz
state_before: x✝ y z✝ x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1 ^ z
Theorem: BoundedContinuousFunction.norm_eq_of_nonempty
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: obtain ⟨a⟩ := h
state_before: F : Type ?u.993399
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
h : Nonempty α
⊢ ‖f‖ = sInf {C | ∀ (x : α), ‖↑f x‖ ≤ C}

tactic: rw [norm_eq]
state_before: case intro
F : Type ?u.993399
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ ‖f‖ = sInf {C | ∀ (x : α), ‖↑f x‖ ≤ C}

tactic: congr
state_before: case intro
F : Type ?u.993399
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖↑f x‖ ≤ C} = sInf {C | ∀ (x : α), ‖↑f x‖ ≤ C}

tactic: ext
state_before: case intro.e_a
F : Type ?u.993399
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ {C | 0 ≤ C ∧ ∀ (x : α), ‖↑f x‖ ≤ C} = {C | ∀ (x : α), ‖↑f x‖ ≤ C}

tactic: simp only [mem_setOf_eq, and_iff_right_iff_imp]
state_before: case intro.e_a.h
F : Type ?u.993399
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
x✝ : ℝ
⊢ x✝ ∈ {C | 0 ≤ C ∧ ∀ (x : α), ‖↑f x‖ ≤ C} ↔ x✝ ∈ {C | ∀ (x : α), ‖↑f x‖ ≤ C}

tactic: exact fun h' => le_trans (norm_nonneg (f a)) (h' a)
state_before: case intro.e_a.h
F : Type ?u.993399
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
x✝ : ℝ
⊢ (∀ (x : α), ‖↑f x‖ ≤ x✝) → 0 ≤ x✝
Theorem: WithTop.coe_add_eq_top_iff
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: induction y using WithTop.recTopCoe <;> simp [← coe_add]
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x y✝ : α
y : WithTop α
⊢ ↑x + y = ⊤ ↔ y = ⊤
Theorem: TopCat.prodIsoProd_hom_snd
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: simp [← Iso.eq_inv_comp, prodIsoProd]
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ (prodIsoProd X Y).hom ≫ prodSnd = prod.snd

tactic: rfl
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ prodSnd = BinaryFan.snd (prodBinaryFan X Y)
Theorem: AlgebraicTopology.DoldKan.σ_comp_PInfty
File: Mathlib/AlgebraicTopology/DoldKan/Degeneracies.lean

tactic: rw [PInfty_f, σ_comp_P_eq_zero X i]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ SimplicialObject.σ X i ≫ HomologicalComplex.Hom.f PInfty (n + 1) = 0

tactic: simp only [le_add_iff_nonneg_left, zero_le]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ n + 1 ≤ ↑i + (n + 1)
Theorem: Submodule.fg_bot
File: Mathlib/RingTheory/Finiteness.lean

tactic: rw [Finset.coe_empty, span_empty]
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ span R ↑∅ = ⊥
Theorem: Polynomial.opRingEquiv_op_C_mul_X_pow
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: simp only [X_pow_mul, op_mul, op_pow, map_mul, map_pow, opRingEquiv_op_X, opRingEquiv_op_C]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
n : ℕ
⊢ ↑(opRingEquiv R) (op (↑C r * X ^ n)) = ↑C (op r) * X ^ n