tasksource/leandojo huggingface dataset:
Theorem: AlgebraicGeometry.PresheafedSpace.map_comp_c_app
File: Mathlib/AlgebraicGeometry/PresheafedSpace/HasColimits.lean

tactic: rw [F.map_comp]
state_before: J : Type u'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base

tactic: rfl
state_before: J : Type u'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map f ≫ F.map g).base

tactic: cases U
state_before: J : Type u'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map (f ≫ g)).c.app U.op =
    (F.map g).c.app U.op ≫
      (pushforwardMap (F.map g).base (F.map f).c).app U.op ≫
        (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv.app U.op ≫
          (pushforwardEq (_ : (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base) (F.obj j₁).presheaf).hom.app U.op

tactic: simp [PresheafedSpace.congr_app (F.map_comp f g)]
state_before: case mk
J : Type u'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
carrier✝ : Set ↑↑(F.obj j₃)
is_open'✝ : IsOpen carrier✝
⊢ (F.map (f ≫ g)).c.app { carrier := carrier✝, is_open' := is_open'✝ }.op =
    (F.map g).c.app { carrier := carrier✝, is_open' := is_open'✝ }.op ≫
      (pushforwardMap (F.map g).base (F.map f).c).app { carrier := carrier✝, is_open' := is_open'✝ }.op ≫
        (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv.app
            { carrier := carrier✝, is_open' := is_open'✝ }.op ≫
          (pushforwardEq (_ : (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base) (F.obj j₁).presheaf).hom.app
            { carrier := carrier✝, is_open' := is_open'✝ }.op
Theorem: minpoly.minpoly_algHom
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: refine' dif_ctx_congr (isIntegral_algHom_iff _ hf) (fun _ => _) fun _ => rfl
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x✝ : B
f : B →ₐ[A] B'
hf : Injective ↑f
x : B
⊢ minpoly A (↑f x) = minpoly A x

tactic: simp_rw [← Polynomial.aeval_def, aeval_algHom, AlgHom.comp_apply, _root_.map_eq_zero_iff f hf]
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x✝¹ : B
f : B →ₐ[A] B'
hf : Injective ↑f
x : B
x✝ : IsIntegral A x
⊢ WellFounded.min (_ : WellFounded fun p q => degree p < degree q)
      (fun x_1 => Monic x_1 ∧ eval₂ (algebraMap A ((fun x => B') x)) (↑f x) x_1 = 0) (_ : IsIntegral A (↑f x)) =
    WellFounded.min (_ : WellFounded fun p q => degree p < degree q)
      (fun x_1 => Monic x_1 ∧ eval₂ (algebraMap A B) x x_1 = 0) x✝
Theorem: Polynomial.ofFinsupp_neg
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [neg_def]
state_before: R✝ : Type u
a✝ b : R✝
m n : ℕ
inst✝¹ : Semiring R✝
p q : R✝[X]
R : Type u
inst✝ : Ring R
a : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := -a } = Polynomial.neg { toFinsupp := a }
Theorem: List.foldr_eq_of_comm'
File: Mathlib/Data/List/Basic.lean

tactic: rw [foldr, foldr, foldr, hf, ← foldr_eq_of_comm' ..]
state_before: ι : Type ?u.251255
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
hf : ∀ (a b : α) (c : β), f a (f b c) = f b (f a c)
a : β
b c : α
l : List α
⊢ foldr f a (b :: c :: l) = foldr f (f b a) (c :: l)

tactic: rfl
state_before: ι : Type ?u.251255
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
hf : ∀ (a b : α) (c : β), f a (f b c) = f b (f a c)
a : β
b c : α
l : List α
⊢ f c (f b (foldr f a l)) = f c (foldr f a (b :: l))
Theorem: Polynomial.splits_of_splits_mul'
File: Mathlib/Data/Polynomial/Splits.lean

tactic: rw [Polynomial.map_mul]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g✝ : K[X]
hfg : map i (f * g✝) ≠ 0
h : Splits i (f * g✝)
g : L[X]
hgi : Irreducible g
hg : g ∣ map i f
⊢ g ∣ map i (f * g✝)

tactic: exact hg.trans (dvd_mul_right _ _)
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g✝ : K[X]
hfg : map i (f * g✝) ≠ 0
h : Splits i (f * g✝)
g : L[X]
hgi : Irreducible g
hg : g ∣ map i f
⊢ g ∣ map i f * map i g✝

tactic: rw [Polynomial.map_mul]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g✝ : K[X]
hfg : map i (f * g✝) ≠ 0
h : Splits i (f * g✝)
g : L[X]
hgi : Irreducible g
hg : g ∣ map i g✝
⊢ g ∣ map i (f * g✝)

tactic: exact hg.trans (dvd_mul_left _ _)
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g✝ : K[X]
hfg : map i (f * g✝) ≠ 0
h : Splits i (f * g✝)
g : L[X]
hgi : Irreducible g
hg : g ∣ map i g✝
⊢ g ∣ map i f * map i g✝
Theorem: MeasureTheory.Lp.simpleFunc.neg_toSimpleFunc
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: filter_upwards [toSimpleFunc_eq_toFun (-f), toSimpleFunc_eq_toFun f,
  Lp.coeFn_neg (f : Lp E p μ)] with _
state_before: α : Type u_1
β : Type ?u.1586018
ι : Type ?u.1586021
E : Type u_2
F : Type ?u.1586027
𝕜 : Type ?u.1586030
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : { x // x ∈ simpleFunc E p μ }
⊢ ↑(toSimpleFunc (-f)) =ᵐ[μ] -↑(toSimpleFunc f)

tactic: simp only [Pi.neg_apply, AddSubgroup.coe_neg]
state_before: case h
α : Type u_1
β : Type ?u.1586018
ι : Type ?u.1586021
E : Type u_2
F : Type ?u.1586027
𝕜 : Type ?u.1586030
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : { x // x ∈ simpleFunc E p μ }
a✝ : α
⊢ ↑(toSimpleFunc (-f)) a✝ = ↑↑↑(-f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ → ↑↑(-↑f) a✝ = (-↑↑↑f) a✝ → ↑(toSimpleFunc (-f)) a✝ = (-↑(toSimpleFunc f)) a✝

tactic: repeat intro h; rw [h]
state_before: case h
α : Type u_1
β : Type ?u.1586018
ι : Type ?u.1586021
E : Type u_2
F : Type ?u.1586027
𝕜 : Type ?u.1586030
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : { x // x ∈ simpleFunc E p μ }
a✝ : α
⊢ ↑(toSimpleFunc (-f)) a✝ = ↑(-↑↑f) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ → ↑(-↑↑f) a✝ = -↑↑↑f a✝ → ↑(toSimpleFunc (-f)) a✝ = -↑(toSimpleFunc f) a✝

tactic: rw [h]
state_before: case h
α : Type u_1
β : Type ?u.1586018
ι : Type ?u.1586021
E : Type u_2
F : Type ?u.1586027
𝕜 : Type ?u.1586030
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : { x // x ∈ simpleFunc E p μ }
a✝ : α
h✝¹ : ↑(toSimpleFunc (-f)) a✝ = ↑(-↑↑f) a✝
h✝ : ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝
h : ↑(-↑↑f) a✝ = -↑↑↑f a✝
⊢ ↑(-↑↑f) a✝ = -↑↑↑f a✝
Theorem: Prod.mk_covby_mk_iff
File: Mathlib/Order/Cover.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b₁) ⋖ (a₂, b₂) ↔ a₁ ⋖ a₂ ∧ b₁ = b₂ ∨ b₁ ⋖ b₂ ∧ a₁ = a₂

tactic: obtain rfl | rfl : a₁ = a₂ ∨ b₁ = b₂ := fst_eq_or_snd_eq_of_wcovby h.wcovby
state_before: case refine'_1
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : (a₁, b₁) ⋖ (a₂, b₂)
⊢ a₁ ⋖ a₂ ∧ b₁ = b₂ ∨ b₁ ⋖ b₂ ∧ a₁ = a₂

tactic: exact Or.inr ⟨mk_covby_mk_iff_right.1 h, rfl⟩
state_before: case refine'_1.inl
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ : α
b b₁ b₂ : β
x y : α × β
h : (a₁, b₁) ⋖ (a₁, b₂)
⊢ a₁ ⋖ a₁ ∧ b₁ = b₂ ∨ b₁ ⋖ b₂ ∧ a₁ = a₁

tactic: exact Or.inl ⟨mk_covby_mk_iff_left.1 h, rfl⟩
state_before: case refine'_1.inr
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ : β
x y : α × β
h : (a₁, b₁) ⋖ (a₂, b₁)
⊢ a₁ ⋖ a₂ ∧ b₁ = b₁ ∨ b₁ ⋖ b₁ ∧ a₁ = a₂

tactic: rintro (⟨h, rfl⟩ | ⟨h, rfl⟩)
state_before: case refine'_2
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ a₁ ⋖ a₂ ∧ b₁ = b₂ ∨ b₁ ⋖ b₂ ∧ a₁ = a₂ → (a₁, b₁) ⋖ (a₂, b₂)

tactic: exact mk_covby_mk_iff_left.2 h
state_before: case refine'_2.inl.intro
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ : β
x y : α × β
h : a₁ ⋖ a₂
⊢ (a₁, b₁) ⋖ (a₂, b₁)

tactic: exact mk_covby_mk_iff_right.2 h
state_before: case refine'_2.inr.intro
α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ : α
b b₁ b₂ : β
x y : α × β
h : b₁ ⋖ b₂
⊢ (a₁, b₁) ⋖ (a₁, b₂)
Theorem: LocalHomeomorph.map_extend_nhds
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [extend_coe, comp_apply, ← I.map_nhds_eq, ← f.map_nhds_eq, map_map]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.138125
M' : Type ?u.138128
H' : Type ?u.138131
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
hy : x ∈ f.source
⊢ map (↑(extend f I)) (𝓝 x) = 𝓝[range ↑I] ↑(extend f I) x
Theorem: IsLocalization.ne_zero_of_mk'_ne_zero
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rintro rfl
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.704959
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
hxy : mk' S x y ≠ 0
⊢ x ≠ 0

tactic: exact hxy (IsLocalization.mk'_zero _)
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.704959
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
y : { x // x ∈ M }
hxy : mk' S 0 y ≠ 0
⊢ False
Theorem: MonoidAlgebra.support_mul_single
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: classical
  ext
  simp only [support_mul_single_eq_image f hr (isRightRegular_of_rightCancelSemigroup x),
    mem_image, mem_map, mulRightEmbedding_apply]
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : RightCancelSemigroup G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
⊢ (f * single x r).support = map (mulRightEmbedding x) f.support

tactic: ext
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : RightCancelSemigroup G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
⊢ (f * single x r).support = map (mulRightEmbedding x) f.support

tactic: simp only [support_mul_single_eq_image f hr (isRightRegular_of_rightCancelSemigroup x),
  mem_image, mem_map, mulRightEmbedding_apply]
state_before: case a
k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : RightCancelSemigroup G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x a✝ : G
⊢ a✝ ∈ (f * single x r).support ↔ a✝ ∈ map (mulRightEmbedding x) f.support
Theorem: SymplecticGroup.inv_left_mul_aux
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: simp only [Matrix.mul_assoc, Matrix.neg_mul]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ -J l R ⬝ Aᵀ ⬝ J l R ⬝ A = (-J l R) ⬝ (Aᵀ ⬝ J l R ⬝ A)

tactic: rw [mem_iff'] at hA
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ (-J l R) ⬝ (Aᵀ ⬝ J l R ⬝ A) = (-J l R) ⬝ J l R

tactic: rw [hA]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : Aᵀ ⬝ J l R ⬝ A = J l R
⊢ (-J l R) ⬝ (Aᵀ ⬝ J l R ⬝ A) = (-J l R) ⬝ J l R

tactic: simp only [Matrix.neg_mul, neg_smul, one_smul]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ (-J l R) ⬝ J l R = -1 • J l R ⬝ J l R

tactic: rw [J_squared]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ -1 • J l R ⬝ J l R = -1 • -1

tactic: simp only [neg_smul_neg, one_smul]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ -1 • -1 = 1
Theorem: continuous_inf_rng
File: Mathlib/Topology/Order.lean

tactic: simp only [continuous_iff_coinduced_le, le_inf_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.40406
f : α → β
ι : Sort ?u.40413
t₁ : TopologicalSpace α
t₂ t₃ : TopologicalSpace β
⊢ Continuous f ↔ Continuous f ∧ Continuous f
Theorem: Stream'.nth_even
File: Mathlib/Data/Stream/Init.lean

tactic: change nth (even s) (succ n) = nth s (succ (succ (2 * n)))
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ nth (even s) (succ n) = nth s (2 * succ n)

tactic: rw [nth_succ, nth_succ, tail_even, nth_even n]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ nth (even s) (succ n) = nth s (succ (succ (2 * n)))

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ nth (tail (tail s)) (2 * n) = nth (tail s) (2 * n + 1)
Theorem: Equiv.subtypeEquiv_symm
File: Mathlib/Logic/Equiv/Basic.lean

tactic: convert (h <| e.symm a).symm
state_before: α : Sort ?u.67949
β : Sort ?u.67953
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (a : α), p a ↔ q (↑e a)
a : β
⊢ q a ↔ p (↑e.symm a)

tactic: exact (e.apply_symm_apply a).symm
state_before: case h.e'_1.h.e'_1
α : Sort ?u.67949
β : Sort ?u.67953
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (a : α), p a ↔ q (↑e a)
a : β
⊢ a = ↑e (↑e.symm a)
Theorem: div_div_div_cancel_right'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← inv_div c b, div_inv_eq_mul, div_mul_div_cancel']
state_before: α : Type ?u.61046
β : Type ?u.61049
G : Type u_1
inst✝ : Group G
a✝ b✝ c✝ d a b c : G
⊢ a / c / (b / c) = a / b
Theorem: Polynomial.coeff_bit1_mul
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: simp [bit1, add_mul, coeff_bit0_mul]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r P Q : R[X]
n : ℕ
⊢ coeff (bit1 P * Q) n = 2 * coeff (P * Q) n + coeff Q n
Theorem: ENNReal.div_pos_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [pos_iff_ne_zero, not_or]
state_before: α : Type ?u.323773
β : Type ?u.323776
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 0 < a / b ↔ a ≠ 0 ∧ b ≠ ⊤
Theorem: Semiquot.IsPure.min
File: Mathlib/Data/Semiquot.lean

tactic: rw [eq_pure h, eq_pure (h.mono st)]
state_before: α : Type u_1
β : Type ?u.16645
s t : Semiquot α
h : IsPure t
st : s ≤ t
⊢ t ≤ s

tactic: simp
state_before: α : Type u_1
β : Type ?u.16645
s t : Semiquot α
h : IsPure t
st : s ≤ t
⊢ pure (get t h) ≤ pure (get s (_ : IsPure s))

tactic: exact h _ (get_mem _) _ (st <| get_mem _)
state_before: α : Type u_1
β : Type ?u.16645
s t : Semiquot α
h : IsPure t
st : s ≤ t
⊢ get t h = get s (_ : IsPure s)
Theorem: Finmap.erase_toFinmap
File: Mathlib/Data/Finmap.lean

tactic: simp [erase]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : AList β
⊢ erase a ⟦s⟧ = ⟦AList.erase a s⟧
Theorem: CircleDeg1Lift.iterate_le_of_map_le_add_int
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [nsmul_eq_mul, add_right_iterate] using
  (f.commute_add_int m).iterate_le_of_map_le f.monotone (monotone_id.add_const (m : ℝ)) h n
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
h : ↑f x ≤ x + ↑m
n : ℕ
⊢ (↑f^[n]) x ≤ x + ↑n * ↑m
Theorem: mem_ball_iff_norm'''
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_ball', dist_eq_norm_div]
state_before: 𝓕 : Type ?u.93030
𝕜 : Type ?u.93033
α : Type ?u.93036
ι : Type ?u.93039
κ : Type ?u.93042
E : Type u_1
F : Type ?u.93048
G : Type ?u.93051
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ ball a r ↔ ‖a / b‖ < r
Theorem: CategoryTheory.Limits.limitIsoLimitCurryCompLim_hom_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: simp [limitIsoLimitCurryCompLim, Trans.simple, HasLimit.isoOfNatIso, limitUncurryIsoLimitCompLim]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit G
inst✝ : HasLimit (curry.obj G ⋙ lim)
j : J
k : K
⊢ (limitIsoLimitCurryCompLim G).hom ≫ limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k = limit.π G (j, k)
Theorem: WittVector.wittMul_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type ?u.66399
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittMul p 0 = X (0, 0) * X (1, 0)

tactic: simp only [wittMul, wittStructureRat, rename_X, xInTermsOfW_zero, map_X, wittPolynomial_zero,
  RingHom.map_mul, bind₁_X_right, AlgHom.map_mul, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type ?u.66399
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ ↑(map (Int.castRingHom ℚ)) (wittMul p 0) = ↑(map (Int.castRingHom ℚ)) (X (0, 0) * X (1, 0))
Theorem: Prime.exists_mem_multiset_map_dvd
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simpa only [exists_prop, Multiset.mem_map, exists_exists_and_eq_and] using
  hp.exists_mem_multiset_dvd h
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.11639
δ : Type ?u.11642
inst✝ : CommMonoidWithZero α
p : α
hp : Prime p
s : Multiset β
f : β → α
h : p ∣ Multiset.prod (Multiset.map f s)
⊢ ∃ a, a ∈ s ∧ p ∣ f a
Theorem: VitaliFamily.fineSubfamilyOn_of_frequently
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: intro x hx ε εpos
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ (x : α), x ∈ s → ∃ᶠ (a : Set α) in filterAt v x, a ∈ f x
⊢ FineSubfamilyOn v f s

tactic: obtain ⟨a, av, ha, af⟩ : ∃ (a : Set α) , a ∈ v.setsAt x ∧ a ⊆ closedBall x ε ∧ a ∈ f x :=
  v.frequently_filterAt_iff.1 (h x hx) ε εpos
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ (x : α), x ∈ s → ∃ᶠ (a : Set α) in filterAt v x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
⊢ ∃ a, a ∈ setsAt v x ∩ f x ∧ a ⊆ closedBall x ε

tactic: exact ⟨a, ⟨av, af⟩, ha⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ (x : α), x ∈ s → ∃ᶠ (a : Set α) in filterAt v x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
a : Set α
av : a ∈ setsAt v x
ha : a ⊆ closedBall x ε
af : a ∈ f x
⊢ ∃ a, a ∈ setsAt v x ∩ f x ∧ a ⊆ closedBall x ε
Theorem: csSup_Iio
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: simpa [and_comm] using exists_between hw
state_before: α : Type u_1
β : Type ?u.51575
γ : Type ?u.51578
ι : Sort ?u.51581
inst✝² : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
w : α
hw : w < a
⊢ ∃ a_1, a_1 ∈ Iio a ∧ w < a_1
Theorem: Nat.le_add_of_sub_le
File: src/lean/Init/Data/Nat/Basic.lean

tactic: match le.dest h, Nat.le_total a b with
| _, Or.inl hle =>
  exact Nat.le_trans hle (Nat.le_add_left ..)
| ⟨d, hd⟩, Or.inr hge =>
  apply @le.intro _ _ d
  rw [Nat.add_comm, ← Nat.add_sub_assoc hge] at hd
  have hd := Nat.eq_add_of_sub_eq (Nat.le_trans hge (Nat.le_add_left ..)) hd
  rw [Nat.add_comm, hd]
state_before: a b c : Nat
h : a - b ≤ c
⊢ a ≤ c + b

tactic: exact Nat.le_trans hle (Nat.le_add_left ..)
state_before: a b c : Nat
h : a - b ≤ c
x✝ : Exists fun k => a - b + k = c
hle : a ≤ b
⊢ a ≤ c + b

tactic: apply @le.intro _ _ d
state_before: a b c : Nat
h : a - b ≤ c
d : Nat
hd : a - b + d = c
hge : b ≤ a
⊢ a ≤ c + b

tactic: rw [Nat.add_comm, ← Nat.add_sub_assoc hge] at hd
state_before: a b c : Nat
h : a - b ≤ c
d : Nat
hd : a - b + d = c
hge : b ≤ a
⊢ a + d = c + b

tactic: have hd := Nat.eq_add_of_sub_eq (Nat.le_trans hge (Nat.le_add_left ..)) hd
state_before: a b c : Nat
h : a - b ≤ c
d : Nat
hd : d + a - b = c
hge : b ≤ a
⊢ a + d = c + b

tactic: rw [Nat.add_comm, hd]
state_before: a b c : Nat
h : a - b ≤ c
d : Nat
hd✝ : d + a - b = c
hge : b ≤ a
hd : d + a = c + b
⊢ a + d = c + b
Theorem: MeasureTheory.FinStronglyMeasurable.neg
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine' ⟨fun n => -hf.approx n, fun n => _, fun x => (hf.tendsto_approx x).neg⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.251943
ι : Type ?u.251946
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
⊢ FinStronglyMeasurable (-f) μ

tactic: suffices μ (Function.support fun x => -(hf.approx n) x) < ∞ by convert this
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.251943
ι : Type ?u.251946
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ ↑↑μ (support ↑((fun n => -FinStronglyMeasurable.approx hf n) n)) < ⊤

tactic: rw [Function.support_neg (hf.approx n)]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.251943
ι : Type ?u.251946
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ ↑↑μ (support fun x => -↑(FinStronglyMeasurable.approx hf n) x) < ⊤

tactic: exact hf.fin_support_approx n
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.251943
ι : Type ?u.251946
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ ↑↑μ (support ↑(FinStronglyMeasurable.approx hf n)) < ⊤

tactic: convert this
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.251943
ι : Type ?u.251946
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
this : ↑↑μ (support fun x => -↑(FinStronglyMeasurable.approx hf n) x) < ⊤
⊢ ↑↑μ (support ↑((fun n => -FinStronglyMeasurable.approx hf n) n)) < ⊤
Theorem: Int.le_max_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.max_def]
state_before: a b : Int
⊢ a ≤ max a b

tactic: split <;> simp [*]
state_before: a b : Int
⊢ a ≤ if a ≤ b then b else a