tasksource/leandojo huggingface dataset:
Theorem: Dfinsupp.sum_mapRange_index.linearMap
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: simpa [Dfinsupp.sumAddHom_apply] using sum_mapRange_index fun i => by simp
state_before: ι : Type u_5
R : Type u_3
S : Type ?u.164559
M : ι → Type ?u.164564
N : Type u_4
dec_ι : DecidableEq ι
inst✝¹² : Semiring R
inst✝¹¹ : (i : ι) → AddCommMonoid (M i)
inst✝¹⁰ : (i : ι) → Module R (M i)
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
β : ι → Type ?u.164654
β₁ : ι → Type u_1
β₂ : ι → Type u_2
inst✝⁷ : (i : ι) → AddCommMonoid (β i)
inst✝⁶ : (i : ι) → AddCommMonoid (β₁ i)
inst✝⁵ : (i : ι) → AddCommMonoid (β₂ i)
inst✝⁴ : (i : ι) → Module R (β i)
inst✝³ : (i : ι) → Module R (β₁ i)
inst✝² : (i : ι) → Module R (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i →ₗ[R] β₂ i
h : (i : ι) → β₂ i →ₗ[R] N
l : Π₀ (i : ι), β₁ i
⊢ ↑(↑(lsum ℕ) h) (↑(mapRange.linearMap f) l) = ↑(↑(lsum ℕ) fun i => LinearMap.comp (h i) (f i)) l

tactic: simp
state_before: ι : Type u_5
R : Type u_3
S : Type ?u.164559
M : ι → Type ?u.164564
N : Type u_4
dec_ι : DecidableEq ι
inst✝¹² : Semiring R
inst✝¹¹ : (i : ι) → AddCommMonoid (M i)
inst✝¹⁰ : (i : ι) → Module R (M i)
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
β : ι → Type ?u.164654
β₁ : ι → Type u_1
β₂ : ι → Type u_2
inst✝⁷ : (i : ι) → AddCommMonoid (β i)
inst✝⁶ : (i : ι) → AddCommMonoid (β₁ i)
inst✝⁵ : (i : ι) → AddCommMonoid (β₂ i)
inst✝⁴ : (i : ι) → Module R (β i)
inst✝³ : (i : ι) → Module R (β₁ i)
inst✝² : (i : ι) → Module R (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i →ₗ[R] β₂ i
h : (i : ι) → β₂ i →ₗ[R] N
l : Π₀ (i : ι), β₁ i
i : ι
⊢ ↑(h i) 0 = 0
Theorem: LinearMap.eq_adjoint_iff_basis_left
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: refine' ⟨fun h x y => by rw [h, adjoint_inner_left], fun h => Basis.ext b fun i => _⟩
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_4
G : Type ?u.2011794
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 E
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
⊢ A = ↑adjoint B ↔ ∀ (i : ι) (y : (fun x => F) (↑b i)), inner (↑A (↑b i)) y = inner (↑b i) (↑B y)

tactic: exact ext_inner_right 𝕜 fun y => by simp only [h i, adjoint_inner_left]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_4
G : Type ?u.2011794
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 E
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i : ι) (y : (fun x => F) (↑b i)), inner (↑A (↑b i)) y = inner (↑b i) (↑B y)
i : ι
⊢ ↑A (↑b i) = ↑(↑adjoint B) (↑b i)

tactic: rw [h, adjoint_inner_left]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_4
G : Type ?u.2011794
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 E
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : A = ↑adjoint B
x : ι
y : (fun x => F) (↑b x)
⊢ inner (↑A (↑b x)) y = inner (↑b x) (↑B y)

tactic: simp only [h i, adjoint_inner_left]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_4
G : Type ?u.2011794
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 E
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i : ι) (y : (fun x => F) (↑b i)), inner (↑A (↑b i)) y = inner (↑b i) (↑B y)
i : ι
y : (fun x => F) (↑b i)
⊢ inner (↑A (↑b i)) y = inner (↑(↑adjoint B) (↑b i)) y
Theorem: Multiset.foldl_induction'
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [foldl_swap]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.134478
f : β → α → β
H : RightCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f b a)
px : p x
q_s : ∀ (a : α), a ∈ s → q a
⊢ p (foldl f H x s)

tactic: exact foldr_induction' (fun x y => f y x) (fun x y z => (H _ _ _).symm) x q p s hpqf px q_s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.134478
f : β → α → β
H : RightCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f b a)
px : p x
q_s : ∀ (a : α), a ∈ s → q a
⊢ p (foldr (fun x y => f y x) (_ : ∀ (_x _y : α) (_z : β), f (f _z _y) _x = f (f _z _x) _y) x s)
Theorem: CocompactMap.isCompact_preimage
File: Mathlib/Topology/ContinuousFunction/CocompactMap.lean

tactic: obtain ⟨t, ht, hts⟩ :=
  mem_cocompact'.mp
    (by
      simpa only [preimage_image_preimage, preimage_compl] using
        mem_map.mp
          (cocompact_tendsto f <|
            mem_cocompact.mpr ⟨s, hs, compl_subset_compl.mpr (image_preimage_subset f _)⟩))
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.10402
δ : Type ?u.10405
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : T2Space β
f : CocompactMap α β
s : Set β
hs : IsCompact s
⊢ IsCompact (↑f ⁻¹' s)

tactic: exact
  isCompact_of_isClosed_subset ht (hs.isClosed.preimage <| map_continuous f) (by simpa using hts)
state_before: case intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.10402
δ : Type ?u.10405
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : T2Space β
f : CocompactMap α β
s : Set β
hs : IsCompact s
t : Set ?m.10680
ht : IsCompact t
hts : ?m.10705ᶜ ⊆ t
⊢ IsCompact (↑f ⁻¹' s)

tactic: simpa only [preimage_image_preimage, preimage_compl] using
  mem_map.mp
    (cocompact_tendsto f <|
      mem_cocompact.mpr ⟨s, hs, compl_subset_compl.mpr (image_preimage_subset f _)⟩)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.10402
δ : Type ?u.10405
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : T2Space β
f : CocompactMap α β
s : Set β
hs : IsCompact s
⊢ ?m.10705 ∈ cocompact α

tactic: simpa using hts
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.10402
δ : Type ?u.10405
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : T2Space β
f : CocompactMap α β
s : Set β
hs : IsCompact s
t : Set α
ht : IsCompact t
hts : (↑f ⁻¹' s)ᶜᶜ ⊆ t
⊢ ↑f ⁻¹' s ⊆ t
Theorem: Real.differentiableWithinAt_arcsin_Iic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

tactic: refine' ⟨fun h => _, fun h => (hasDerivWithinAt_arcsin_Iic h).differentiableWithinAt⟩
state_before: x : ℝ
⊢ DifferentiableWithinAt ℝ arcsin (Iic x) x ↔ x ≠ 1

tactic: rw [← neg_neg x, ← image_neg_Ici] at h
state_before: x : ℝ
h : DifferentiableWithinAt ℝ arcsin (Iic x) x
⊢ x ≠ 1

tactic: have := (h.comp (-x) differentiableWithinAt_id.neg (mapsTo_image _ _)).neg
state_before: x : ℝ
h : DifferentiableWithinAt ℝ arcsin (Neg.neg '' Ici (-x)) (- -x)
⊢ x ≠ 1
Theorem: BilinForm.toMatrix_compRight
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [BilinForm.compRight, BilinForm.toMatrix_comp b b, toMatrix_id, transpose_one,
  Matrix.one_mul]
state_before: R : Type ?u.1541084
M : Type ?u.1541087
inst✝²⁰ : Semiring R
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : Module R M
R₁ : Type ?u.1541123
M₁ : Type ?u.1541126
inst✝¹⁷ : Ring R₁
inst✝¹⁶ : AddCommGroup M₁
inst✝¹⁵ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁴ : CommSemiring R₂
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R₂ M₂
R₃ : Type ?u.1541925
M₃ : Type ?u.1541928
inst✝¹¹ : CommRing R₃
inst✝¹⁰ : AddCommGroup M₃
inst✝⁹ : Module R₃ M₃
V : Type ?u.1542516
K : Type ?u.1542519
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_3
o : Type ?u.1543736
inst✝⁵ : Fintype n
inst✝⁴ : Fintype o
inst✝³ : DecidableEq n
b : Basis n R₂ M₂
M₂' : Type ?u.1543895
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
c : Basis o R₂ M₂'
inst✝ : DecidableEq o
B : BilinForm R₂ M₂
f : M₂ →ₗ[R₂] M₂
⊢ ↑(toMatrix b) (compRight B f) = ↑(toMatrix b) B ⬝ ↑(LinearMap.toMatrix b b) f
Theorem: Pretrivialization.target_inter_preimage_symm_source_eq
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [inter_comm, f.target_eq, e.source_eq, f.preimage_symm_proj_inter]
state_before: ι : Type ?u.10841
B : Type u_1
F : Type u_2
E : B → Type ?u.10852
Z : Type u_3
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e f : Pretrivialization F proj
⊢ f.target ∩ ↑(LocalEquiv.symm f.toLocalEquiv) ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ univ
Theorem: Submodule.one_eq_span
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: apply Submodule.ext
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ 1 = span R {1}

tactic: intro a
state_before: case h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ ∀ (x : A), x ∈ 1 ↔ x ∈ span R {1}

tactic: simp only [mem_one, mem_span_singleton, Algebra.smul_def, mul_one]
state_before: case h
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n a : A
⊢ a ∈ 1 ↔ a ∈ span R {1}
Theorem: Set.Iic_union_Ioc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_total c d with hcd hcd <;> simp [hcd] at h
state_before: α : Type u_1
β : Type ?u.101649
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : min c d < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)

tactic: exact Iic_union_Ioc' h
state_before: case inl
α : Type u_1
β : Type ?u.101649
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : c ≤ d
h : c < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)

tactic: rw [max_comm]
state_before: case inr
α : Type u_1
β : Type ?u.101649
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d ≤ c
h : d < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)

tactic: simp [*, max_eq_right_of_lt h]
state_before: case inr
α : Type u_1
β : Type ?u.101649
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d ≤ c
h : d < b
⊢ Iic b ∪ Ioc c d = Iic (max d b)
Theorem: Ordinal.IsLimit.one_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [succ_zero] using h.2 _ h.pos
state_before: α : Type ?u.93011
β : Type ?u.93014
γ : Type ?u.93017
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : IsLimit o
⊢ 1 < o
Theorem: CategoryTheory.Functor.isSplitEpi_iff
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: constructor
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u₃
inst✝² : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : Full F
inst✝ : Faithful F
⊢ IsSplitEpi (F.map f) ↔ IsSplitEpi f

tactic: intro h
state_before: case mp
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u₃
inst✝² : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : Full F
inst✝ : Faithful F
⊢ IsSplitEpi (F.map f) → IsSplitEpi f

tactic: exact IsSplitEpi.mk' ((splitEpiEquiv F f).invFun h.exists_splitEpi.some)
state_before: case mp
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u₃
inst✝² : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : Full F
inst✝ : Faithful F
h : IsSplitEpi (F.map f)
⊢ IsSplitEpi f

tactic: intro h
state_before: case mpr
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u₃
inst✝² : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : Full F
inst✝ : Faithful F
⊢ IsSplitEpi f → IsSplitEpi (F.map f)

tactic: exact IsSplitEpi.mk' ((splitEpiEquiv F f).toFun h.exists_splitEpi.some)
state_before: case mpr
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u₃
inst✝² : Category E
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : Full F
inst✝ : Faithful F
h : IsSplitEpi f
⊢ IsSplitEpi (F.map f)
Theorem: Filter.push_pull
File: Mathlib/Order/Filter/Basic.lean

tactic: apply le_antisymm
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f (F ⊓ comap f G) = map f F ⊓ G

tactic: calc
  map f (F ⊓ comap f G) ≤ map f F ⊓ (map f <| comap f G) := map_inf_le
  _ ≤ map f F ⊓ G := inf_le_inf_left (map f F) map_comap_le
state_before: case a
α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f (F ⊓ comap f G) ≤ map f F ⊓ G

tactic: rintro U ⟨V, V_in, W, ⟨Z, Z_in, hZ⟩, h⟩
state_before: case a
α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f F ⊓ G ≤ map f (F ⊓ comap f G)

tactic: apply mem_inf_of_inter (image_mem_map V_in) Z_in
state_before: case a.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ U ∈ map f F ⊓ G

tactic: calc
  f '' V ∩ Z = f '' (V ∩ f ⁻¹' Z) := by rw [image_inter_preimage]
  _ ⊆ f '' (V ∩ W) := image_subset _ (inter_subset_inter_right _ ‹_›)
  _ = f '' (f ⁻¹' U) := by rw [h]
  _ ⊆ U := image_preimage_subset f U
state_before: case a.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ f '' V ∩ Z ⊆ U

tactic: rw [image_inter_preimage]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ f '' V ∩ Z = f '' (V ∩ f ⁻¹' Z)

tactic: rw [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.286447
ι : Sort x
f : α → β
F : Filter α
G : Filter β
U : Set β
V : Set α
V_in : V ∈ F
W : Set α
h : f ⁻¹' U = V ∩ W
Z : Set β
Z_in : Z ∈ G
hZ : f ⁻¹' Z ⊆ W
⊢ f '' (V ∩ W) = f '' (f ⁻¹' U)
Theorem: Subtype.exists_set_subtype
File: Mathlib/Data/Set/Image.lean

tactic: rw [← exists_subset_range_and_iff, range_coe]
state_before: α : Type u_1
t : Set α
p : Set α → Prop
⊢ (∃ s, p (val '' s)) ↔ ∃ s, s ⊆ t ∧ p s
Theorem: pow_mono
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [pow_succ]
state_before: β : Type ?u.218801
A : Type ?u.218804
G : Type ?u.218807
M : Type ?u.218810
R : Type u_1
inst✝ : OrderedSemiring R
a x y : R
n✝ m : ℕ
h : 1 ≤ a
n : ℕ
⊢ a ^ n ≤ a ^ (n + 1)

tactic: exact le_mul_of_one_le_left (pow_nonneg (zero_le_one.trans h) _) h
state_before: β : Type ?u.218801
A : Type ?u.218804
G : Type ?u.218807
M : Type ?u.218810
R : Type u_1
inst✝ : OrderedSemiring R
a x y : R
n✝ m : ℕ
h : 1 ≤ a
n : ℕ
⊢ a ^ n ≤ a * a ^ n
Theorem: UniqueMul.set_subsingleton
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: rintro ⟨x1, y1⟩ (hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0) ⟨x2, y2⟩
  (hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0)
state_before: G : Type u_1
H : Type ?u.1533
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ Set.Subsingleton {ab | ab.fst ∈ A ∧ ab.snd ∈ B ∧ ab.fst * ab.snd = a0 * b0}

tactic: rcases h hx.1 hx.2.1 hx.2.2 with ⟨rfl, rfl⟩
state_before: case mk.mk
G : Type u_1
H : Type ?u.1533
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x1 y1 : G
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0
x2 y2 : G
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0
⊢ (x1, y1) = (x2, y2)

tactic: rcases h hy.1 hy.2.1 hy.2.2 with ⟨rfl, rfl⟩
state_before: case mk.mk.intro
G : Type u_1
H : Type ?u.1533
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0 b0 : G
A B : Finset G
x1 y1 x2 y2 : G
h : UniqueMul A B x1 y1
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = x1 * y1
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x1 * y1
⊢ (x1, y1) = (x2, y2)

tactic: rfl
state_before: case mk.mk.intro.intro
G : Type u_1
H : Type ?u.1533
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0 b0 : G
A B : Finset G
x2 y2 : G
h : UniqueMul A B x2 y2
hx hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x2 * y2
⊢ (x2, y2) = (x2, y2)
Theorem: Nat.gcd_eq_right_iff_dvd
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm]
state_before: m n : Nat
⊢ m ∣ n ↔ gcd n m = m

tactic: exact gcd_eq_left_iff_dvd
state_before: m n : Nat
⊢ m ∣ n ↔ gcd m n = m
Theorem: CategoryTheory.Subobject.factorThru_comp_arrow
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category D
X Y : C
P : Subobject Y
f : X ⟶ underlying.obj P
h : Factors P (f ≫ arrow P)
⊢ factorThru P (f ≫ arrow P) h = f

tactic: simp
state_before: case h
C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category D
X Y : C
P : Subobject Y
f : X ⟶ underlying.obj P
h : Factors P (f ≫ arrow P)
⊢ factorThru P (f ≫ arrow P) h ≫ arrow P = f ≫ arrow P
Theorem: Finset.exists_lt_sum_fiber_of_maps_to_of_nsmul_lt_sum
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simpa only [sum_fiberwise_of_maps_to hf, sum_const]
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCancelAddCommMonoid M
hf : ∀ (a : α), a ∈ s → f a ∈ t
hb : card t • b < ∑ x in s, w x
⊢ ∑ i in t, b < ∑ i in t, ∑ x in filter (fun x => f x = i) s, w x
Theorem: IsCoprime.add_mul_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [isCoprime_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + x * z)

tactic: exact h.symm.add_mul_left_left z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (y + x * z) x
Theorem: Fin.pos_iff_ne_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← val_fin_lt, val_zero, _root_.pos_iff_ne_zero, Ne.def, Ne.def, ext_iff, val_zero]
state_before: n m : ℕ
inst✝ : NeZero n
a : Fin n
⊢ 0 < a ↔ a ≠ 0
Theorem: CategoryTheory.NatTrans.mono_of_mono_app
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: ext X
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G H I : C ⥤ D
α : F ⟶ G
inst✝ : ∀ (X : C), Mono (α.app X)
Z✝ : C ⥤ D
g h : Z✝ ⟶ F
eq : g ≫ α = h ≫ α
⊢ g = h

tactic: rw [← cancel_mono (α.app X), ← comp_app, eq, comp_app]
state_before: case w.h
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G H I : C ⥤ D
α : F ⟶ G
inst✝ : ∀ (X : C), Mono (α.app X)
Z✝ : C ⥤ D
g h : Z✝ ⟶ F
eq : g ≫ α = h ≫ α
X : C
⊢ g.app X = h.app X
Theorem: Polynomial.eval₂_at_zero
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp (config := { contextual := true }) only [eval₂_eq_sum, zero_pow_eq, mul_ite, mul_zero,
  mul_one, sum, Classical.not_not, mem_support_iff, sum_ite_eq', ite_eq_left_iff,
  RingHom.map_zero, imp_true_iff, eq_self_iff_true]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
⊢ eval₂ f 0 p = ↑f (coeff p 0)
Theorem: Real.Angle.two_zsmul_coe_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← coe_zsmul, two_zsmul, add_halves]
state_before: θ : ℝ
⊢ 2 • ↑(θ / 2) = ↑θ
Theorem: BoxIntegral.Box.coe_ae_eq_Icc
File: Mathlib/Analysis/BoxIntegral/Partition/Measure.lean

tactic: rw [coe_eq_pi]
state_before: ι : Type u_1
I : Box ι
inst✝ : Fintype ι
⊢ ↑I =ᵐ[volume] ↑Box.Icc I

tactic: exact Measure.univ_pi_Ioc_ae_eq_Icc
state_before: ι : Type u_1
I : Box ι
inst✝ : Fintype ι
⊢ (pi univ fun i => Ioc (lower I i) (upper I i)) =ᵐ[volume] ↑Box.Icc I
Theorem: ContinuousLinearMap.sSup_unit_ball_eq_norm
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simpa only [NNReal.coe_sSup, Set.image_image] using NNReal.coe_eq.2 f.sSup_unit_ball_eq_nnnorm
state_before: 𝕜✝ : Type ?u.819707
𝕜₂✝ : Type ?u.819710
𝕜₃ : Type ?u.819713
E✝ : Type ?u.819716
Eₗ : Type ?u.819719
F✝ : Type ?u.819722
Fₗ : Type ?u.819725
G : Type ?u.819728
Gₗ : Type ?u.819731
𝓕 : Type ?u.819734
inst✝²³ : SeminormedAddCommGroup E✝
inst✝²² : SeminormedAddCommGroup Eₗ
inst✝²¹ : SeminormedAddCommGroup F✝
inst✝²⁰ : SeminormedAddCommGroup Fₗ
inst✝¹⁹ : SeminormedAddCommGroup G
inst✝¹⁸ : SeminormedAddCommGroup Gₗ
inst✝¹⁷ : NontriviallyNormedField 𝕜✝
inst✝¹⁶ : NontriviallyNormedField 𝕜₂✝
inst✝¹⁵ : NontriviallyNormedField 𝕜₃
inst✝¹⁴ : NormedSpace 𝕜✝ E✝
inst✝¹³ : NormedSpace 𝕜✝ Eₗ
inst✝¹² : NormedSpace 𝕜₂✝ F✝
inst✝¹¹ : NormedSpace 𝕜✝ Fₗ
inst✝¹⁰ : NormedSpace 𝕜₃ G
inst✝⁹ : NormedSpace 𝕜✝ Gₗ
σ₁₂✝ : 𝕜✝ →+* 𝕜₂✝
σ₂₃ : 𝕜₂✝ →+* 𝕜₃
σ₁₃ : 𝕜✝ →+* 𝕜₃
inst✝⁸ : RingHomCompTriple σ₁₂✝ σ₂₃ σ₁₃
inst✝⁷ : RingHomIsometric σ₁₂✝
𝕜 : Type u_1
𝕜₂ : Type u_2
E : Type u_3
F : Type u_4
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : DenselyNormedField 𝕜
inst✝³ : NontriviallyNormedField 𝕜₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜₂ F
inst✝ : RingHomIsometric σ₁₂
f : E →SL[σ₁₂] F
⊢ sSup ((fun x => ‖↑f x‖) '' ball 0 1) = ‖f‖
Theorem: Multiset.prod_X_add_C_coeff'
File: Mathlib/RingTheory/Polynomial/Vieta.lean

tactic: erw [← map_map (fun r => X + C r) r, prod_X_add_C_coeff] <;> rw [s.card_map r]
state_before: R : Type u_2
inst✝ : CommSemiring R
σ : Type u_1
s : Multiset σ
r : σ → R
k : ℕ
h : k ≤ ↑card s
⊢ coeff (prod (map (fun i => X + ↑C (r i)) s)) k = esymm (map r s) (↑card s - k)

tactic: assumption
state_before: case h
R : Type u_2
inst✝ : CommSemiring R
σ : Type u_1
s : Multiset σ
r : σ → R
k : ℕ
h : k ≤ ↑card s
⊢ k ≤ ↑card s