tasksource/leandojo huggingface dataset:
Theorem: trans_trichotomous_right
File: Mathlib/Order/RelClasses.lean

tactic: intro h₁ h₂
state_before: α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsTrans α r
inst✝ : IsTrichotomous α r
a b c : α
⊢ r a b → ¬r c b → r a c

tactic: rcases trichotomous_of r b c with (h₃ | rfl | h₃)
state_before: α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsTrans α r
inst✝ : IsTrichotomous α r
a b c : α
h₁ : r a b
h₂ : ¬r c b
⊢ r a c

tactic: exacts [_root_.trans h₁ h₃, h₁, absurd h₃ h₂]
state_before: case inl
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsTrans α r
inst✝ : IsTrichotomous α r
a b c : α
h₁ : r a b
h₂ : ¬r c b
h₃ : r b c
⊢ r a c

case inr.inl
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsTrans α r
inst✝ : IsTrichotomous α r
a b : α
h₁ : r a b
h₂ : ¬r b b
⊢ r a b

case inr.inr
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsTrans α r
inst✝ : IsTrichotomous α r
a b c : α
h₁ : r a b
h₂ : ¬r c b
h₃ : r c b
⊢ r a c
Theorem: spectrum.zero_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: refine' Set.Subset.antisymm _ (by simp [Algebra.algebraMap_eq_smul_one, mem_iff])
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
⊢ σ 0 = {0}

tactic: rw [spectrum, Set.compl_subset_comm]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
⊢ σ 0 ⊆ {0}

tactic: intro k hk
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
⊢ {0}ᶜ ⊆ resolventSet 𝕜 0

tactic: rw [Set.mem_compl_singleton_iff] at hk
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
k : 𝕜
hk : k ∈ {0}ᶜ
⊢ k ∈ resolventSet 𝕜 0

tactic: have : IsUnit (Units.mk0 k hk • (1 : A)) := IsUnit.smul (Units.mk0 k hk) isUnit_one
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
k : 𝕜
hk : k ≠ 0
⊢ k ∈ resolventSet 𝕜 0

tactic: simpa [mem_resolventSet_iff, Algebra.algebraMap_eq_smul_one]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
k : 𝕜
hk : k ≠ 0
this : IsUnit (Units.mk0 k hk • 1)
⊢ k ∈ resolventSet 𝕜 0

tactic: simp [Algebra.algebraMap_eq_smul_one, mem_iff]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
⊢ {0} ⊆ σ 0
Theorem: nhdsWithin_Iic_basis'
File: Mathlib/Topology/Order/Basic.lean

tactic: convert @nhdsWithin_Ici_basis' αᵒᵈ _ _ _ (toDual a) ha using 2
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
⊢ HasBasis (𝓝[Iic a] a) (fun l => l < a) fun l => Ioc l a

tactic: exact (@dual_Ico _ _ _ _).symm
state_before: case h.e'_5.h.h
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
e_1✝ e_2✝ : α = αᵒᵈ
x✝ : α
⊢ Ioc x✝ a = Ico (↑toDual a) x✝
Theorem: MulAction.Supports.smul
File: Mathlib/GroupTheory/GroupAction/Support.lean

tactic: rintro g' hg'
state_before: G : Type u_1
H : Type u_4
α : Type u_2
β : Type u_3
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
⊢ Supports G (g • s) (g • b)

tactic: rw [smul_comm, h]
state_before: G : Type u_1
H : Type u_4
α : Type u_2
β : Type u_3
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
⊢ g' • g • b = g • b

tactic: rintro a ha
state_before: case a
G : Type u_1
H : Type u_4
α : Type u_2
β : Type u_3
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
⊢ ∀ ⦃a : α⦄, a ∈ s → g' • a = a

tactic: have := Set.ball_image_iff.1 hg' a ha
state_before: case a
G : Type u_1
H : Type u_4
α : Type u_2
β : Type u_3
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
a : α
ha : a ∈ s
⊢ g' • a = a

tactic: rwa [smul_comm, smul_left_cancel_iff] at this
state_before: case a
G : Type u_1
H : Type u_4
α : Type u_2
β : Type u_3
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
a : α
ha : a ∈ s
this : g' • g • a = g • a
⊢ g' • a = a
Theorem: toIcoDiv_add_left'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIcoDiv_add_right']
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1
Theorem: Dfinsupp.piecewise_single_erase
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
⊢ piecewise (single i (↑x i)) (erase i x) {i} = x

tactic: rw [piecewise_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
⊢ ↑(piecewise (single i (↑x i)) (erase i x) {i}) j = ↑x j

tactic: split_ifs with h
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
⊢ (if j ∈ {i} then ↑(single i (↑x i)) j else ↑(erase i x) j) = ↑x j

tactic: rw [(id h : j = i), single_eq_same]
state_before: case h.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
h : j ∈ {i}
⊢ ↑(single i (↑x i)) j = ↑x j

tactic: exact erase_ne h
state_before: case h.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
x : Π₀ (i : ι), β i
i : ι
inst✝ : (i' : ι) → Decidable (i' ∈ {i})
j : ι
h : ¬j ∈ {i}
⊢ ↑(erase i x) j = ↑x j
Theorem: Mathlib.Meta.NormNum.IsNat.to_isInt
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑n✝ = ↑(Int.ofNat n✝)
Theorem: MeasureTheory.Measure.zero_le_toSignedMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [← le_restrict_univ_iff_le]
state_before: α : Type u_1
β : Type ?u.719217
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
⊢ 0 ≤ toSignedMeasure μ

tactic: refine' restrict_le_restrict_of_subset_le _ _ fun j hj₁ _ => _
state_before: α : Type u_1
β : Type ?u.719217
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
⊢ VectorMeasure.restrict 0 Set.univ ≤ VectorMeasure.restrict (toSignedMeasure μ) Set.univ

tactic: simp only [Measure.toSignedMeasure_apply_measurable hj₁, coe_zero, Pi.zero_apply,
  ENNReal.toReal_nonneg, VectorMeasure.coe_zero]
state_before: α : Type u_1
β : Type ?u.719217
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
j : Set α
hj₁ : MeasurableSet j
x✝ : j ⊆ Set.univ
⊢ ↑0 j ≤ ↑(toSignedMeasure μ) j
Theorem: uniformity_prod_eq_comap_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: dsimp [SProd.sprod]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.153564
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
⊢ 𝓤 (α × β) = comap (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) (𝓤 α ×ˢ 𝓤 β)

tactic: rw [uniformity_prod, Filter.prod, comap_inf, comap_comap, comap_comap]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.153564
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
⊢ 𝓤 (α × β) = comap (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) (Filter.prod (𝓤 α) (𝓤 β))

tactic: rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.153564
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
⊢ comap (fun p => (p.fst.fst, p.snd.fst)) (𝓤 α) ⊓ comap (fun p => (p.fst.snd, p.snd.snd)) (𝓤 β) =
    comap (Prod.fst ∘ fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) (𝓤 α) ⊓
      comap (Prod.snd ∘ fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) (𝓤 β)
Theorem: Stream'.dropLast_take
File: Mathlib/Data/Stream/Init.lean

tactic: cases n
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
α✝ : Type u_1
xs : Stream' α✝
⊢ List.dropLast (take n xs) = take (n - 1) xs

tactic: case zero => simp
state_before: case zero
α : Type u
β : Type v
δ : Type w
α✝ : Type u_1
xs : Stream' α✝
⊢ List.dropLast (take zero xs) = take (zero - 1) xs

case succ
α : Type u
β : Type v
δ : Type w
α✝ : Type u_1
xs : Stream' α✝
n✝ : ℕ
⊢ List.dropLast (take (succ n✝) xs) = take (succ n✝ - 1) xs

tactic: case succ n => rw [take_succ', List.dropLast_concat, Nat.succ_sub_one]
state_before: case succ
α : Type u
β : Type v
δ : Type w
α✝ : Type u_1
xs : Stream' α✝
n✝ : ℕ
⊢ List.dropLast (take (succ n✝) xs) = take (succ n✝ - 1) xs

tactic: simp
state_before: α : Type u
β : Type v
δ : Type w
α✝ : Type u_1
xs : Stream' α✝
⊢ List.dropLast (take zero xs) = take (zero - 1) xs

tactic: rw [take_succ', List.dropLast_concat, Nat.succ_sub_one]
state_before: α : Type u
β : Type v
δ : Type w
α✝ : Type u_1
xs : Stream' α✝
n : ℕ
⊢ List.dropLast (take (succ n) xs) = take (succ n - 1) xs
Theorem: CategoryTheory.MonoidalFunctor.map_rightUnitor
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: simp only [LaxMonoidalFunctor.right_unitality]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫ (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (ρ_ (F.obj X)).hom

tactic: slice_rhs 2 3 =>
  rw [← id_tensor_comp]
  simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫
      (𝟙 (F.obj X) ⊗ inv F.ε) ≫
        (𝟙 (F.obj X) ⊗ F.ε) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C) ≫ F.map (ρ_ X).hom

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫
      (𝟙 (F.obj X ⊗ F.obj (𝟙_ C)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫ F.map (ρ_ X).hom
Theorem: inv_mem_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rwa [← nhds_one_symm'] at hS
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x : α
S : Set G
hS : S ∈ 𝓝 1
⊢ S⁻¹ ∈ 𝓝 1
Theorem: Set.preimage_liftCover
File: Mathlib/Data/Set/UnionLift.lean

tactic: change (iUnionLift S f hf univ hS.symm.subset ∘ fun a => ⟨a, mem_univ a⟩) ⁻¹' t = _
state_before: α : Type u_2
ι : Sort u_3
β : Type u_1
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
hS : iUnion S = univ
t : Set β
⊢ liftCover S f hf hS ⁻¹' t = ⋃ (i : ι), Subtype.val '' (f i ⁻¹' t)

tactic: rw [preimage_comp, preimage_iUnionLift]
state_before: α : Type u_2
ι : Sort u_3
β : Type u_1
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
hS : iUnion S = univ
t : Set β
⊢ (iUnionLift S f hf univ (_ : univ ⊆ iUnion S) ∘ fun a => { val := a, property := (_ : a ∈ univ) }) ⁻¹' t =
    ⋃ (i : ι), Subtype.val '' (f i ⁻¹' t)

tactic: ext
state_before: α : Type u_2
ι : Sort u_3
β : Type u_1
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
hS : iUnion S = univ
t : Set β
⊢ (fun a => { val := a, property := (_ : a ∈ univ) }) ⁻¹'
      (inclusion (_ : univ ⊆ iUnion S) ⁻¹' ⋃ (i : ι), inclusion (_ : S i ⊆ ⋃ (i : ι), S i) '' (f i ⁻¹' t)) =
    ⋃ (i : ι), Subtype.val '' (f i ⁻¹' t)

tactic: simp
state_before: case h
α : Type u_2
ι : Sort u_3
β : Type u_1
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
hS : iUnion S = univ
t : Set β
x✝ : α
⊢ x✝ ∈
      (fun a => { val := a, property := (_ : a ∈ univ) }) ⁻¹'
        (inclusion (_ : univ ⊆ iUnion S) ⁻¹' ⋃ (i : ι), inclusion (_ : S i ⊆ ⋃ (i : ι), S i) '' (f i ⁻¹' t)) ↔
    x✝ ∈ ⋃ (i : ι), Subtype.val '' (f i ⁻¹' t)
Theorem: NormedAddGroupHom.coe_inj
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: cases f
state_before: V : Type ?u.108968
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.108977
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
H : ↑f = ↑g
⊢ f = g

tactic: cases g
state_before: case mk
V : Type ?u.108968
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.108977
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
g : NormedAddGroupHom V₁ V₂
toFun✝ : V₁ → V₂
map_add'✝ : ∀ (v₁ v₂ : V₁), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : V₁), ‖toFun✝ v‖ ≤ C * ‖v‖
H : ↑{ toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = ↑g
⊢ { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = g

tactic: congr
state_before: case mk.mk
V : Type ?u.108968
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.108977
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
toFun✝¹ : V₁ → V₂
map_add'✝¹ : ∀ (v₁ v₂ : V₁), toFun✝¹ (v₁ + v₂) = toFun✝¹ v₁ + toFun✝¹ v₂
bound'✝¹ : ∃ C, ∀ (v : V₁), ‖toFun✝¹ v‖ ≤ C * ‖v‖
toFun✝ : V₁ → V₂
map_add'✝ : ∀ (v₁ v₂ : V₁), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : V₁), ‖toFun✝ v‖ ≤ C * ‖v‖
H :
  ↑{ toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    ↑{ toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
⊢ { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
Theorem: Array.back_push
File: Std/Data/Array/Lemmas.lean

tactic: simp
state_before: α : Type u_1
x : α
inst✝ : Inhabited α
a : Array α
⊢ back (push a x) = x
Theorem: PadicInt.norm_sub_modPart
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: let n := modPart p r
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
⊢ ‖{ val := ↑r, property := h } - ↑(modPart p r)‖ < 1

tactic: rw [norm_lt_one_iff_dvd, ← (isUnit_den r h).dvd_mul_right]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
⊢ ‖{ val := ↑r, property := h } - ↑(modPart p r)‖ < 1

tactic: suffices ↑p ∣ r.num - n * r.den by
  convert(Int.castRingHom ℤ_[p]).map_dvd this
  simp only [sub_mul, Int.cast_ofNat, eq_intCast, Int.cast_mul, sub_left_inj, Int.cast_sub]
  apply Subtype.coe_injective
  simp only [coe_mul, Subtype.coe_mk, coe_nat_cast]
  rw_mod_cast [@Rat.mul_den_eq_num r]
  rfl
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
⊢ ↑p ∣ ({ val := ↑r, property := h } - ↑(modPart p r)) * ↑r.den

tactic: exact norm_sub_modPart_aux r h
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
⊢ ↑p ∣ r.num - n * ↑r.den

tactic: convert(Int.castRingHom ℤ_[p]).map_dvd this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
this : ↑p ∣ r.num - n * ↑r.den
⊢ ↑p ∣ ({ val := ↑r, property := h } - ↑(modPart p r)) * ↑r.den

tactic: simp only [sub_mul, Int.cast_ofNat, eq_intCast, Int.cast_mul, sub_left_inj, Int.cast_sub]
state_before: case h.e'_4
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
this : ↑p ∣ r.num - n * ↑r.den
⊢ ({ val := ↑r, property := h } - ↑(modPart p r)) * ↑r.den = ↑(Int.castRingHom ℤ_[p]) (r.num - n * ↑r.den)

tactic: apply Subtype.coe_injective
state_before: case h.e'_4
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
this : ↑p ∣ r.num - n * ↑r.den
⊢ { val := ↑r, property := h } * ↑r.den = ↑r.num

tactic: simp only [coe_mul, Subtype.coe_mk, coe_nat_cast]
state_before: case h.e'_4.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
this : ↑p ∣ r.num - n * ↑r.den
⊢ (fun a => ↑a) ({ val := ↑r, property := h } * ↑r.den) = (fun a => ↑a) ↑r.num

tactic: rw_mod_cast [@Rat.mul_den_eq_num r]
state_before: case h.e'_4.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
h : ‖↑r‖ ≤ 1
n : ℤ := modPart p r
this : ↑p ∣ r.num - n * ↑r.den
⊢ ↑r * ↑r.den = ↑↑r.num

tactic: rfl
state_before: case h.e'_4.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
n : ℤ := modPart p r
this : ↑p ∣ r.num - n * ↑r.den
h : ‖↑r‖ ≤ 1
⊢ ↑↑r.num = ↑r.num
Theorem: MeasureTheory.ae_eq_of_forall_set_lintegral_eq_of_sigmaFinite
File: Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean

tactic: have A : f ≤ᵐ[μ] g :=
  ae_le_of_forall_set_lintegral_le_of_sigmaFinite hf hg fun s hs h's => le_of_eq (h s hs h's)
state_before: α : Type u_1
E : Type ?u.67365
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
inst✝ : SigmaFinite μ
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫⁻ (x : α) in s, f x ∂μ) = ∫⁻ (x : α) in s, g x ∂μ
⊢ f =ᵐ[μ] g

tactic: have B : g ≤ᵐ[μ] f :=
  ae_le_of_forall_set_lintegral_le_of_sigmaFinite hg hf fun s hs h's => ge_of_eq (h s hs h's)
state_before: α : Type u_1
E : Type ?u.67365
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
inst✝ : SigmaFinite μ
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫⁻ (x : α) in s, f x ∂μ) = ∫⁻ (x : α) in s, g x ∂μ
A : f ≤ᵐ[μ] g
⊢ f =ᵐ[μ] g

tactic: filter_upwards [A, B] with x using le_antisymm
state_before: α : Type u_1
E : Type ?u.67365
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
inst✝ : SigmaFinite μ
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
h : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → (∫⁻ (x : α) in s, f x ∂μ) = ∫⁻ (x : α) in s, g x ∂μ
A : f ≤ᵐ[μ] g
B : g ≤ᵐ[μ] f
⊢ f =ᵐ[μ] g
Theorem: binary_relation_sInf_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [sInf_apply]
state_before: α✝ : Type ?u.205042
β✝ : Type ?u.205045
β₂ : Type ?u.205048
γ : Type ?u.205051
ι : Sort ?u.205054
ι' : Sort ?u.205057
κ : ι → Sort ?u.205062
κ' : ι' → Sort ?u.205067
α : Type u_1
β : Type u_2
s : Set (α → β → Prop)
a : α
b : β
⊢ sInf s a b ↔ ∀ (r : α → β → Prop), r ∈ s → r a b

tactic: simp [← eq_iff_iff]
state_before: α✝ : Type ?u.205042
β✝ : Type ?u.205045
β₂ : Type ?u.205048
γ : Type ?u.205051
ι : Sort ?u.205054
ι' : Sort ?u.205057
κ : ι → Sort ?u.205062
κ' : ι' → Sort ?u.205067
α : Type u_1
β : Type u_2
s : Set (α → β → Prop)
a : α
b : β
⊢ iInf (fun f => ↑f a) b ↔ ∀ (r : α → β → Prop), r ∈ s → r a b
Theorem: SignType.lt_one_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ a < 1 ↔ a ≤ 0
Theorem: Equiv.Perm.pow_apply_mem_toList_iff_mem_support
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: rw [mem_toList_iff, and_iff_right_iff_imp]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
⊢ ↑(p ^ n) x ∈ toList p x ↔ x ∈ support p

tactic: refine' fun _ => SameCycle.symm _
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
⊢ x ∈ support p → SameCycle p x (↑(p ^ n) x)

tactic: rw [sameCycle_pow_left]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
x✝ : x ∈ support p
⊢ SameCycle p (↑(p ^ n) x) x
Theorem: Zsqrtd.mul_star
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [ext, sub_eq_add_neg, mul_comm]
state_before: d x y : ℤ
⊢ { re := x, im := y } * star { re := x, im := y } = ↑x * ↑x - ↑d * ↑y * ↑y
Theorem: Polynomial.rootMultiplicity_le_iff
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [← (le_rootMultiplicity_iff p0).not, not_le, Nat.lt_add_one_iff]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
p0 : p ≠ 0
a : R
n : ℕ
⊢ rootMultiplicity a p ≤ n ↔ ¬(X - ↑C a) ^ (n + 1) ∣ p
Theorem: Cardinal.lift_sum
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_mk_eq.{_,_,v}, mk_out, mk_out, lift_lift]
state_before: α β ι : Type u
f : ι → Cardinal
a : ι
⊢ Nonempty (Quotient.out (f a) ≃ Quotient.out ((fun i => lift (f i)) a))
Theorem: mem_primitiveRoots
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [primitiveRoots, mem_filter, Multiset.mem_toFinset, mem_nthRoots h0, and_iff_right_iff_imp]
state_before: M : Type ?u.1450185
N : Type ?u.1450188
G : Type ?u.1450191
R : Type u_1
S : Type ?u.1450197
F : Type ?u.1450200
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
h0 : 0 < k
⊢ ζ ∈ primitiveRoots k R ↔ IsPrimitiveRoot ζ k

tactic: exact IsPrimitiveRoot.pow_eq_one
state_before: M : Type ?u.1450185
N : Type ?u.1450188
G : Type ?u.1450191
R : Type u_1
S : Type ?u.1450197
F : Type ?u.1450200
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
h0 : 0 < k
⊢ IsPrimitiveRoot ζ k → ζ ^ k = 1