tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.tendsto_indicator_ge
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: refine' tendsto_atTop_of_eventually_const (i₀ := Nat.ceil (‖f x‖₊ : ℝ) + 1) fun n hn => _
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.15743
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
x : α
⊢ Tendsto (fun M => Set.indicator {x | ↑M ≤ ↑‖f x‖₊} f x) atTop (𝓝 0)

tactic: rw [Set.indicator_of_not_mem]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.15743
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
x : α
n : ℕ
hn : n ≥ ⌈↑‖f x‖₊⌉₊ + 1
⊢ Set.indicator {x | ↑n ≤ ↑‖f x‖₊} f x = 0

tactic: simp only [not_le, Set.mem_setOf_eq]
state_before: case h
α : Type u_2
β : Type u_1
ι : Type ?u.15743
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
x : α
n : ℕ
hn : n ≥ ⌈↑‖f x‖₊⌉₊ + 1
⊢ ¬x ∈ {x | ↑n ≤ ↑‖f x‖₊}

tactic: refine' lt_of_le_of_lt (Nat.le_ceil _) _
state_before: case h
α : Type u_2
β : Type u_1
ι : Type ?u.15743
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
x : α
n : ℕ
hn : n ≥ ⌈↑‖f x‖₊⌉₊ + 1
⊢ ↑‖f x‖₊ < ↑n

tactic: refine' lt_of_lt_of_le (lt_add_one _) _
state_before: case h
α : Type u_2
β : Type u_1
ι : Type ?u.15743
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
x : α
n : ℕ
hn : n ≥ ⌈↑‖f x‖₊⌉₊ + 1
⊢ ↑⌈↑‖f x‖₊⌉₊ < ↑n

tactic: norm_cast
state_before: case h
α : Type u_2
β : Type u_1
ι : Type ?u.15743
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f : α → β
x : α
n : ℕ
hn : n ≥ ⌈↑‖f x‖₊⌉₊ + 1
⊢ ↑⌈↑‖f x‖₊⌉₊ + 1 ≤ ↑n
Theorem: SimpleGraph.Path.not_mem_edges_of_loop
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [p.loop_eq]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
e : Sym2 V
p : Path G v v
⊢ ¬e ∈ Walk.edges ↑p
Theorem: Int.eq_mul_of_ediv_eq_right
File: Std/Data/Int/DivMod.lean

tactic: rw [← H2, Int.mul_ediv_cancel' H1]
state_before: a b c : Int
H1 : b ∣ a
H2 : a / b = c
⊢ a = b * c
Theorem: Pell.xz_succ_succ
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: delta xz
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ xz a1 (n + 2) + xz a1 n = ↑(2 * a) * xz a1 (n + 1)

tactic: rw [← Int.ofNat_add, ← Int.ofNat_mul, xn_succ_succ]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ ↑(xn a1 (n + 2)) + ↑(xn a1 n) = ↑(2 * a) * ↑(xn a1 (n + 1))
Theorem: Complex.hasStrictDerivAt_log
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

tactic: rintro rfl
state_before: x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ x ≠ 0

tactic: simp [lt_irrefl] at h
state_before: h : 0 < 0.re ∨ 0.im ≠ 0
⊢ False

tactic: simpa [exp_log h0] using hasStrictDerivAt_exp (log x)
state_before: x : ℂ
h : 0 < x.re ∨ x.im ≠ 0
h0 : x ≠ 0
⊢ HasStrictDerivAt (↑expLocalHomeomorph) x (↑(LocalHomeomorph.symm expLocalHomeomorph) x)
Theorem: MultilinearMap.comp_linearEquiv_eq_zero_iff
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: set f' := fun i => (f i : M₁ i →ₗ[R] M₁' i)
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁴ : Semiring R
inst✝¹³ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹² : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁷ : (i : ι) → Module R (M₁ i)
inst✝⁶ : Module R M₂
inst✝⁵ : Module R M₃
inst✝⁴ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
M₁' : ι → Type u_1
inst✝³ : (i : ι) → AddCommMonoid (M₁' i)
inst✝² : (i : ι) → Module R (M₁' i)
M₁'' : ι → Type ?u.182590
inst✝¹ : (i : ι) → AddCommMonoid (M₁'' i)
inst✝ : (i : ι) → Module R (M₁'' i)
g : MultilinearMap R M₁' M₂
f : (i : ι) → M₁ i ≃ₗ[R] M₁' i
⊢ (compLinearMap g fun i => ↑(f i)) = 0 ↔ g = 0

tactic: rw [← zero_compLinearMap f', compLinearMap_inj f' fun i => (f i).surjective]
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁴ : Semiring R
inst✝¹³ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹² : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁷ : (i : ι) → Module R (M₁ i)
inst✝⁶ : Module R M₂
inst✝⁵ : Module R M₃
inst✝⁴ : Module R M'
f✝ f'✝ : MultilinearMap R M₁ M₂
M₁' : ι → Type u_1
inst✝³ : (i : ι) → AddCommMonoid (M₁' i)
inst✝² : (i : ι) → Module R (M₁' i)
M₁'' : ι → Type ?u.182590
inst✝¹ : (i : ι) → AddCommMonoid (M₁'' i)
inst✝ : (i : ι) → Module R (M₁'' i)
g : MultilinearMap R M₁' M₂
f : (i : ι) → M₁ i ≃ₗ[R] M₁' i
f' : (i : ι) → M₁ i →ₗ[R] M₁' i := fun i => ↑(f i)
⊢ compLinearMap g f' = 0 ↔ g = 0
Theorem: WittVector.mapFun.injective
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: intros _ _ h
state_before: p : ℕ
R : Type ?u.19105
S : Type ?u.19108
T : Type ?u.19111
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
⊢ Injective (mapFun f)

tactic: ext p
state_before: p : ℕ
R : Type ?u.19105
S : Type ?u.19108
T : Type ?u.19111
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
a₁✝ a₂✝ : 𝕎 α
h : mapFun f a₁✝ = mapFun f a₂✝
⊢ a₁✝ = a₂✝

tactic: exact hf (congr_arg (fun x => coeff x p) h : _)
state_before: case h
p✝ : ℕ
R : Type ?u.19105
S : Type ?u.19108
T : Type ?u.19111
hp : Fact (Nat.Prime p✝)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
a₁✝ a₂✝ : WittVector p✝ α
h : mapFun f a₁✝ = mapFun f a₂✝
p : ℕ
⊢ coeff a₁✝ p = coeff a₂✝ p
Theorem: Nat.le_of_le_of_sub_le_sub_right
File: Std/Data/Nat/Lemmas.lean

tactic: simp [succ_sub_succ] at h₁
state_before: n m k : Nat
h₀ : succ k ≤ succ m
h₁ : succ n - succ k ≤ succ m - succ k
⊢ succ n ≤ succ m

tactic: exact succ_le_succ <| Nat.le_of_le_of_sub_le_sub_right (le_of_succ_le_succ h₀) h₁
state_before: n m k : Nat
h₀ : succ k ≤ succ m
h₁ : n - k ≤ m - k
⊢ succ n ≤ succ m
Theorem: CategoryTheory.Bicategory.rightUnitor_comp_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ (f ≫ g)).inv = f ◁ (ρ_ g).inv ≫ (α_ f g (𝟙 c)).inv
Theorem: Int.neg_mul_eq_neg_mul
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.add_mul, Int.add_right_neg, Int.zero_mul]
state_before: a b : Int
⊢ a * b + -a * b = 0
Theorem: leftLim_eq_of_tendsto
File: Mathlib/Topology/Algebra/Order/LeftRightLim.lean

tactic: have h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y) := ⟨y, h'⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[Iio a] a ≠ ⊥
h' : Tendsto f (𝓝[Iio a] a) (𝓝 y)
⊢ leftLim f a = y

tactic: rw [h'α.topology_eq_generate_intervals] at h h' h''
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[Iio a] a ≠ ⊥
h' : Tendsto f (𝓝[Iio a] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[Iio a] a) (𝓝 y)
⊢ leftLim f a = y

tactic: simp only [leftLim, h, h'', not_true, or_self_iff, if_false]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[Iio a] a ≠ ⊥
h' : Tendsto f (𝓝[Iio a] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[Iio a] a) (𝓝 y)
⊢ leftLim f a = y

tactic: haveI := neBot_iff.2 h
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[Iio a] a ≠ ⊥
h' : Tendsto f (𝓝[Iio a] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[Iio a] a) (𝓝 y)
⊢ limUnder (𝓝[Iio a] a) f = y

tactic: exact lim_eq h'
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[Iio a] a ≠ ⊥
h' : Tendsto f (𝓝[Iio a] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[Iio a] a) (𝓝 y)
this : NeBot (𝓝[Iio a] a)
⊢ limUnder (𝓝[Iio a] a) f = y
Theorem: Ideal.span_pair_comm
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: simp only [span_insert, sup_comm]
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
⊢ span {x, y} = span {y, x}
Theorem: Associates.rel_associated_iff_map_eq_map
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: rw [← Multiset.rel_eq, Multiset.rel_map]
state_before: α : Type u_1
β : Type ?u.35843
γ : Type ?u.35846
δ : Type ?u.35849
inst✝ : CommMonoid α
p q : Multiset α
⊢ Multiset.Rel Associated p q ↔ Multiset.map Associates.mk p = Multiset.map Associates.mk q

tactic: simp only [mk_eq_mk_iff_associated]
state_before: α : Type u_1
β : Type ?u.35843
γ : Type ?u.35846
δ : Type ?u.35849
inst✝ : CommMonoid α
p q : Multiset α
⊢ Multiset.Rel Associated p q ↔ Multiset.Rel (fun a b => Associates.mk a = Associates.mk b) p q
Theorem: Submodule.quotientRel_r_def
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rw [leftRel_apply, sub_eq_add_neg, neg_add, neg_neg]
state_before: R : Type u_2
M : Type u_1
r : R
x✝ y✝ : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
x y : M
⊢ Setoid.r x y ↔ -(x - y) ∈ p

tactic: rfl
state_before: R : Type u_2
M : Type u_1
r : R
x✝ y✝ : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
x y : M
⊢ -x + y ∈ toAddSubgroup p ↔ -x + y ∈ p
Theorem: Finset.mem_offDiag
File: Mathlib/Data/Finset/Prod.lean

tactic: simp [offDiag, and_assoc]
state_before: α : Type u_1
β : Type ?u.101302
γ : Type ?u.101305
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ x ∈ offDiag s ↔ x.fst ∈ s ∧ x.snd ∈ s ∧ x.fst ≠ x.snd
Theorem: CategoryTheory.isCodetector_iff_reflectsIsomorphisms_yoneda_obj
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine' ⟨fun hG => ⟨fun f hf => _⟩, fun h => (isCodetector_def _).2 fun X Y f hf => _⟩
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
⊢ IsCodetector G ↔ ReflectsIsomorphisms (yoneda.obj G)

tactic: refine' (isIso_unop_iff _).1 (hG.def _ _)
state_before: case refine'_1
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
hG : IsCodetector G
A✝ B✝ : Cᵒᵖ
f : A✝ ⟶ B✝
hf : IsIso ((yoneda.obj G).map f)
⊢ IsIso f

tactic: rwa [isIso_iff_bijective, Function.bijective_iff_existsUnique] at hf
state_before: case refine'_1
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
hG : IsCodetector G
A✝ B✝ : Cᵒᵖ
f : A✝ ⟶ B✝
hf : IsIso ((yoneda.obj G).map f)
⊢ ∀ (h : B✝.unop ⟶ G), ∃! h', f.unop ≫ h' = h

tactic: rw [← isIso_op_iff]
state_before: case refine'_2
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
h : ReflectsIsomorphisms (yoneda.obj G)
X Y : C
f : X ⟶ Y
hf : ∀ (h : X ⟶ G), ∃! h', f ≫ h' = h
⊢ IsIso f

tactic: suffices IsIso ((yoneda.obj G).map f.op) by
  exact @isIso_of_reflects_iso _ _ _ _ _ _ _ (yoneda.obj G) _ h
state_before: case refine'_2
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
h : ReflectsIsomorphisms (yoneda.obj G)
X Y : C
f : X ⟶ Y
hf : ∀ (h : X ⟶ G), ∃! h', f ≫ h' = h
⊢ IsIso f.op

tactic: rwa [isIso_iff_bijective, Function.bijective_iff_existsUnique]
state_before: case refine'_2
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
h : ReflectsIsomorphisms (yoneda.obj G)
X Y : C
f : X ⟶ Y
hf : ∀ (h : X ⟶ G), ∃! h', f ≫ h' = h
⊢ IsIso ((yoneda.obj G).map f.op)

tactic: exact @isIso_of_reflects_iso _ _ _ _ _ _ _ (yoneda.obj G) _ h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : C
h : ReflectsIsomorphisms (yoneda.obj G)
X Y : C
f : X ⟶ Y
hf : ∀ (h : X ⟶ G), ∃! h', f ≫ h' = h
this : IsIso ((yoneda.obj G).map f.op)
⊢ IsIso f.op
Theorem: List.map_eq_mapTR
File: src/lean/Init/Data/List/Basic.lean

tactic: simp [mapTR, mapTR_loop_eq]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_2
β : Type u_1
f : α → β
as : List α
⊢ map f as = mapTR f as
Theorem: TopCat.Presheaf.Pushforward.id_eq
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: unfold pushforwardObj
state_before: C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
⊢ 𝟙 X _* ℱ = ℱ

tactic: rw [Opens.map_id_eq]
state_before: C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
⊢ Functor.op (Opens.map (𝟙 X)) ⋙ ℱ = ℱ

tactic: erw [Functor.id_comp]
state_before: C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
⊢ Functor.op (𝟭 (Opens ↑X)) ⋙ ℱ = ℱ
Theorem: MeasureTheory.Integrable.right_of_add_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at h ⊢
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.840553
δ : Type ?u.840556
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f
⊢ Integrable f

tactic: exact h.right_of_add_measure
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.840553
δ : Type ?u.840556
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Memℒp f 1
⊢ Memℒp f 1
Theorem: op_nnnorm_mul_flip
File: Mathlib/Analysis/NormedSpace/Star/Mul.lean

tactic: rw [← sSup_unit_ball_eq_nnnorm, ← nnnorm_star, ← @op_nnnorm_mul 𝕜 E, ← sSup_unit_ball_eq_nnnorm]
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a : E
⊢ ‖↑(ContinuousLinearMap.flip (mul 𝕜 E)) a‖₊ = ‖a‖₊

tactic: congr 1
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a : E
⊢ sSup ((fun x => ‖↑(↑(ContinuousLinearMap.flip (mul 𝕜 E)) a) x‖₊) '' Metric.ball 0 1) =
    sSup ((fun x => ‖↑(↑(mul 𝕜 E) a⋆) x‖₊) '' Metric.ball 0 1)

tactic: simp only [mul_apply', flip_apply]
state_before: case e_a
𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a : E
⊢ (fun x => ‖↑(↑(ContinuousLinearMap.flip (mul 𝕜 E)) a) x‖₊) '' Metric.ball 0 1 =
    (fun x => ‖↑(↑(mul 𝕜 E) a⋆) x‖₊) '' Metric.ball 0 1

tactic: refine' Set.Subset.antisymm _ _ <;> rintro - ⟨b, hb, rfl⟩ <;>
  refine' ⟨star b, by simpa only [norm_star, mem_ball_zero_iff] using hb, _⟩
state_before: case e_a
𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a : E
⊢ (fun a_1 => ‖a_1 * a‖₊) '' Metric.ball 0 1 = (fun a_1 => ‖a⋆ * a_1‖₊) '' Metric.ball 0 1

tactic: simpa only [norm_star, mem_ball_zero_iff] using hb
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a b : E
hb : b ∈ Metric.ball 0 1
⊢ b⋆ ∈ Metric.ball 0 1

tactic: simp only [← star_mul, nnnorm_star]
state_before: case e_a.refine'_1.intro.intro
𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a b : E
hb : b ∈ Metric.ball 0 1
⊢ (fun a_1 => ‖a⋆ * a_1‖₊) b⋆ = (fun a_1 => ‖a_1 * a‖₊) b

tactic: simpa using (nnnorm_star (star b * a)).symm
state_before: case e_a.refine'_2.intro.intro
𝕜 : Type u_2
E : Type u_1
inst✝⁶ : DenselyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing E
inst✝⁴ : StarRing E
inst✝³ : CstarRing E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : IsScalarTower 𝕜 E E
inst✝ : SMulCommClass 𝕜 E E
a b : E
hb : b ∈ Metric.ball 0 1
⊢ (fun a_1 => ‖a_1 * a‖₊) b⋆ = (fun a_1 => ‖a⋆ * a_1‖₊) b
Theorem: PiNat.cylinder_eq_res
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: ext y
state_before: E : ℕ → Type ?u.22143
α : Type u_1
x : ℕ → α
n : ℕ
⊢ cylinder x n = {y | res y n = res x n}

tactic: dsimp [cylinder]
state_before: case h
E : ℕ → Type ?u.22143
α : Type u_1
x : ℕ → α
n : ℕ
y : ℕ → α
⊢ y ∈ cylinder x n ↔ y ∈ {y | res y n = res x n}

tactic: rw [res_eq_res]
state_before: case h
E : ℕ → Type ?u.22143
α : Type u_1
x : ℕ → α
n : ℕ
y : ℕ → α
⊢ (∀ (i : ℕ), i < n → y i = x i) ↔ res y n = res x n
Theorem: Filter.tendsto_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [Tendsto]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.307631
ι : Sort x
f : α → β
l : Filter β
⊢ Tendsto f ⊥ l
Theorem: round_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [abs_sub_round_eq_min, min_le_iff]
state_before: F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
⊢ abs (x - ↑(round x)) ≤ abs (x - ↑z)

tactic: rcases le_or_lt (z : α) x with (hx | hx) <;> [left; right]
state_before: F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
⊢ fract x ≤ abs (x - ↑z) ∨ 1 - fract x ≤ abs (x - ↑z)

tactic: conv_rhs => rw [abs_eq_self.mpr (sub_nonneg.mpr hx), ← fract_add_floor x, add_sub_assoc]
state_before: case inl.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : ↑z ≤ x
⊢ fract x ≤ abs (x - ↑z)

tactic: simpa only [le_add_iff_nonneg_right, sub_nonneg, cast_le] using le_floor.mpr hx
state_before: case inl.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : ↑z ≤ x
⊢ fract x ≤ fract x + (↑⌊x⌋ - ↑z)

tactic: rw [abs_eq_neg_self.mpr (sub_neg.mpr hx).le]
state_before: case inr.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : x < ↑z
⊢ 1 - fract x ≤ abs (x - ↑z)

tactic: conv_rhs => rw [← fract_add_floor x]
state_before: case inr.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : x < ↑z
⊢ 1 - fract x ≤ -(x - ↑z)

tactic: rw [add_sub_assoc, add_comm, neg_add, neg_sub, le_add_neg_iff_add_le, sub_add_cancel,
  le_sub_comm]
state_before: case inr.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : x < ↑z
⊢ 1 - fract x ≤ -(fract x + ↑⌊x⌋ - ↑z)

tactic: norm_cast
state_before: case inr.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : x < ↑z
⊢ ↑⌊x⌋ ≤ ↑z - 1

tactic: exact floor_le_sub_one_iff.mpr hx
state_before: case inr.h
F : Type ?u.264762
α : Type u_1
β : Type ?u.264768
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
z : ℤ
hx : x < ↑z
⊢ ⌊x⌋ ≤ z - 1
Theorem: Pairwise.exists_mem_filter_of_disjoint
File: Mathlib/Order/Filter/Basic.lean

tactic: have : ∀ i j, i ≠ j → ∃ (s : {s // s ∈ l i}) (t : {t // t ∈ l j}), Disjoint s.1 t.1
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.87127
ι✝ : Sort x
f g : Filter α
s t : Set α
ι : Type u_1
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)

tactic: choose! s t hst using this
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.87127
ι✝ : Sort x
f g : Filter α
s t : Set α
ι : Type u_1
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
this : ∀ (i j : ι), i ≠ j → ∃ s t, Disjoint ↑s ↑t
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)

tactic: refine' ⟨fun i => ⋂ j, s i j ∩ t j i, fun i => _, fun i j hij => _⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.87127
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_1
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
s : (i : ι) → ι → { s // s ∈ l i }
t : ι → (j : ι) → { t // t ∈ l j }
hst : ∀ (i j : ι), i ≠ j → Disjoint ↑(s i j) ↑(t i j)
⊢ ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)

tactic: exacts [iInter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,
  (hst _ _ hij).mono ((iInter_subset _ j).trans (inter_subset_left _ _))
    ((iInter_subset _ i).trans (inter_subset_right _ _))]
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type ?u.87127
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_1
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
s : (i : ι) → ι → { s // s ∈ l i }
t : ι → (j : ι) → { t // t ∈ l j }
hst : ∀ (i j : ι), i ≠ j → Disjoint ↑(s i j) ↑(t i j)
i : ι
⊢ (fun i => ⋂ (j : ι), ↑(s i j) ∩ ↑(t j i)) i ∈ l i

case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type ?u.87127
ι✝ : Sort x
f g : Filter α
s✝ t✝ : Set α
ι : Type u_1
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
s : (i : ι) → ι → { s // s ∈ l i }
t : ι → (j : ι) → { t // t ∈ l j }
hst : ∀ (i j : ι), i ≠ j → Disjoint ↑(s i j) ↑(t i j)
i j : ι
hij : i ≠ j
⊢ (Disjoint on fun i => ⋂ (j : ι), ↑(s i j) ∩ ↑(t j i)) i j

tactic: simpa only [Pairwise, Function.onFun, Filter.disjoint_iff, exists_prop, Subtype.exists] using hd
state_before: case this
α : Type u
β : Type v
γ : Type w
δ : Type ?u.87127
ι✝ : Sort x
f g : Filter α
s t : Set α
ι : Type u_1
inst✝ : Finite ι
l : ι → Filter α
hd : Pairwise (Disjoint on l)
⊢ ∀ (i j : ι), i ≠ j → ∃ s t, Disjoint ↑s ↑t
Theorem: LinearMap.snd_eq_coprod
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.85660
M₆ : Type ?u.85663
S : Type ?u.85666
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
⊢ snd R M M₂ = coprod 0 id

tactic: simp
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.85660
M₆ : Type ?u.85663
S : Type ?u.85666
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
x✝ : M × M₂
⊢ ↑(snd R M M₂) x✝ = ↑(coprod 0 id) x✝
Theorem: Finset.prod_ne_zero_iff
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Ne, prod_eq_zero_iff]
state_before: ι : Type ?u.875346
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoidWithZero β
inst✝¹ : Nontrivial β
inst✝ : NoZeroDivisors β
⊢ ∏ x in s, f x ≠ 0 ↔ ∀ (a : α), a ∈ s → f a ≠ 0

tactic: push_neg
state_before: ι : Type ?u.875346
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoidWithZero β
inst✝¹ : Nontrivial β
inst✝ : NoZeroDivisors β
⊢ (¬∃ a, a ∈ s ∧ f a = 0) ↔ ∀ (a : α), a ∈ s → f a ≠ 0

tactic: rfl
state_before: ι : Type ?u.875346
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoidWithZero β
inst✝¹ : Nontrivial β
inst✝ : NoZeroDivisors β
⊢ (∀ (a : α), a ∈ s → f a ≠ 0) ↔ ∀ (a : α), a ∈ s → f a ≠ 0