tasksource/leandojo huggingface dataset:
Theorem: Set.mul_eq_one_iff
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
⊢ s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

tactic: have hst : (s * t).Nonempty := h.symm.subst one_nonempty
state_before: case refine'_1
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

tactic: obtain ⟨a, ha⟩ := hst.of_image2_left
state_before: case refine'_1
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
hst : Set.Nonempty (s * t)
⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

tactic: obtain ⟨b, hb⟩ := hst.of_image2_right
state_before: case refine'_1.intro
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
hst : Set.Nonempty (s * t)
a : α
ha : a ∈ s
⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

tactic: have H : ∀ {a b}, a ∈ s → b ∈ t → a * b = (1 : α) := fun {a b} ha hb =>
  h.subset <| mem_image2_of_mem ha hb
state_before: case refine'_1.intro.intro
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
hst : Set.Nonempty (s * t)
a : α
ha : a ∈ s
b : α
hb : b ∈ t
⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

tactic: refine' ⟨a, b, _, _, H ha hb⟩ <;> refine' eq_singleton_iff_unique_mem.2 ⟨‹_›, fun x hx => _⟩
state_before: case refine'_1.intro.intro
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
hst : Set.Nonempty (s * t)
a : α
ha : a ∈ s
b : α
hb : b ∈ t
H : ∀ {a b : α}, a ∈ s → b ∈ t → a * b = 1
⊢ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

tactic: exact (eq_inv_of_mul_eq_one_left <| H hx hb).trans (inv_eq_of_mul_eq_one_left <| H ha hb)
state_before: case refine'_1.intro.intro.refine'_1
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
hst : Set.Nonempty (s * t)
a : α
ha : a ∈ s
b : α
hb : b ∈ t
H : ∀ {a b : α}, a ∈ s → b ∈ t → a * b = 1
x : α
hx : x ∈ s
⊢ x = a

tactic: exact (eq_inv_of_mul_eq_one_right <| H ha hx).trans (inv_eq_of_mul_eq_one_right <| H ha hb)
state_before: case refine'_1.intro.intro.refine'_2
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
h : s * t = 1
hst : Set.Nonempty (s * t)
a : α
ha : a ∈ s
b : α
hb : b ∈ t
H : ∀ {a b : α}, a ∈ s → b ∈ t → a * b = 1
x : α
hx : x ∈ t
⊢ x = b

tactic: rintro ⟨b, c, rfl, rfl, h⟩
state_before: case refine'_2
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
s t : Set α
⊢ (∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1) → s * t = 1

tactic: rw [singleton_mul_singleton, h, singleton_one]
state_before: case refine'_2.intro.intro.intro.intro
F : Type ?u.80713
α : Type u_1
β : Type ?u.80719
γ : Type ?u.80722
inst✝ : DivisionMonoid α
b c : α
h : b * c = 1
⊢ {b} * {c} = 1
Theorem: Real.logb_lt_iff_lt_rpow_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_lt_rpow_left_iff_of_base_lt_one b_pos b_lt_one, rpow_logb b_pos (b_ne_one b_lt_one) hx]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
⊢ logb b x < y ↔ b ^ y < x
Theorem: Path.Homotopy.eval_zero
File: Mathlib/Topology/Homotopy/Path.lean

tactic: ext t
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
⊢ eval F 0 = p₀

tactic: simp [eval]
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
t : ↑I
⊢ ↑(eval F 0) t = ↑p₀ t
Theorem: himp_left_comm
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [himp_himp, inf_comm]
state_before: ι : Type ?u.70104
α : Type u_1
β : Type ?u.70110
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ a ⇨ b ⇨ c = b ⇨ a ⇨ c
Theorem: ContinuousLinearMap.intervalIntegral_comp_comm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp_rw [intervalIntegral, L.integral_comp_comm hf.1, L.integral_comp_comm hf.2, L.map_sub]
state_before: ι : Type ?u.14661329
𝕜 : Type u_1
E : Type u_2
F : Type u_3
A : Type ?u.14661341
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NormedSpace ℝ E
a b : ℝ
μ : MeasureTheory.Measure ℝ
f : ℝ → E
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
L : E →L[𝕜] F
hf : IntervalIntegrable f μ a b
⊢ (∫ (x : ℝ) in a..b, ↑L (f x) ∂μ) = ↑L (∫ (x : ℝ) in a..b, f x ∂μ)
Theorem: re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [@norm_add_mul_self 𝕜, @norm_sub_mul_self 𝕜]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2586554
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x y) = (‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2586554
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x y) = (‖x‖ * ‖x‖ + 2 * ↑re (inner x y) + ‖y‖ * ‖y‖ - (‖x‖ * ‖x‖ - 2 * ↑re (inner x y) + ‖y‖ * ‖y‖)) / 4
Theorem: CategoryTheory.IsPushout.of_isColimit
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : PushoutCocone f g
h : IsColimit c
⊢ PushoutCocone.inl c ≫ (Iso.refl c.pt).hom =
    PushoutCocone.inl
      (PushoutCocone.mk (PushoutCocone.inl c) (PushoutCocone.inr c)
        (_ : f ≫ PushoutCocone.inl c = g ≫ PushoutCocone.inr c))

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : PushoutCocone f g
h : IsColimit c
⊢ PushoutCocone.inr c ≫ (Iso.refl c.pt).hom =
    PushoutCocone.inr
      (PushoutCocone.mk (PushoutCocone.inl c) (PushoutCocone.inr c)
        (_ : f ≫ PushoutCocone.inl c = g ≫ PushoutCocone.inr c))
Theorem: Set.mem_Ici_Ioi_of_subset_of_subset
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← Ioi_union_left, union_subset_iff]
state_before: α : Type u_1
β : Type ?u.49056
inst✝ : PartialOrder α
a b c : α
s : Set α
ho : Ioi a ⊆ s
hc : s ⊆ Ici a
h : a ∈ s
⊢ Ici a ⊆ s

tactic: simp [*]
state_before: α : Type u_1
β : Type ?u.49056
inst✝ : PartialOrder α
a b c : α
s : Set α
ho : Ioi a ⊆ s
hc : s ⊆ Ici a
h : a ∈ s
⊢ Ioi a ⊆ s ∧ {a} ⊆ s
Theorem: IsPrimitiveRoot.primitiveRoots_one
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: apply Finset.eq_singleton_iff_unique_mem.2
state_before: M : Type ?u.2760785
N : Type ?u.2760788
G : Type ?u.2760791
R : Type u_1
S : Type ?u.2760797
F : Type ?u.2760800
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
ζ : R
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ primitiveRoots 1 R = {1}

tactic: constructor
state_before: M : Type ?u.2760785
N : Type ?u.2760788
G : Type ?u.2760791
R : Type u_1
S : Type ?u.2760797
F : Type ?u.2760800
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
ζ : R
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ 1 ∈ primitiveRoots 1 R ∧ ∀ (x : R), x ∈ primitiveRoots 1 R → x = 1

tactic: simp only [IsPrimitiveRoot.one_right_iff, mem_primitiveRoots zero_lt_one]
state_before: case left
M : Type ?u.2760785
N : Type ?u.2760788
G : Type ?u.2760791
R : Type u_1
S : Type ?u.2760797
F : Type ?u.2760800
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
ζ : R
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ 1 ∈ primitiveRoots 1 R

tactic: intro x hx
state_before: case right
M : Type ?u.2760785
N : Type ?u.2760788
G : Type ?u.2760791
R : Type u_1
S : Type ?u.2760797
F : Type ?u.2760800
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
ζ : R
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ ∀ (x : R), x ∈ primitiveRoots 1 R → x = 1

tactic: rw [mem_primitiveRoots zero_lt_one, IsPrimitiveRoot.one_right_iff] at hx
state_before: case right
M : Type ?u.2760785
N : Type ?u.2760788
G : Type ?u.2760791
R : Type u_1
S : Type ?u.2760797
F : Type ?u.2760800
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
ζ : R
inst✝¹ : CommRing R
inst✝ : IsDomain R
x : R
hx : x ∈ primitiveRoots 1 R
⊢ x = 1

tactic: exact hx
state_before: case right
M : Type ?u.2760785
N : Type ?u.2760788
G : Type ?u.2760791
R : Type u_1
S : Type ?u.2760797
F : Type ?u.2760800
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
ζ : R
inst✝¹ : CommRing R
inst✝ : IsDomain R
x : R
hx : x = 1
⊢ x = 1
Theorem: CategoryTheory.Limits.Multicoequalizer.ι_sigmaπ
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [sigmaπ, ← Category.assoc, Iso.comp_inv_eq, isoCoequalizer]
state_before: C : Type u
inst✝³ : Category C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ sigmaπ I = π I b

tactic: simp only [MultispanIndex.multicoforkEquivSigmaCofork_inverse,
  MultispanIndex.ofSigmaCoforkFunctor_obj, colimit.isoColimitCocone_ι_hom,
  Multicofork.ofSigmaCofork_pt, colimit.cocone_x, Multicofork.π_eq_app_right]
state_before: C : Type u
inst✝³ : Category C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ coequalizer.π (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I) =
    π I b ≫
      (colimit.isoColimitCocone
          {
            cocone :=
              (MultispanIndex.multicoforkEquivSigmaCofork I).inverse.obj
                (colimit.cocone (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I))),
            isColimit :=
              IsColimit.ofPreservesCoconeInitial (MultispanIndex.multicoforkEquivSigmaCofork I).inverse
                (colimit.isColimit (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I))) }).hom

tactic: rfl
state_before: C : Type u
inst✝³ : Category C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ coequalizer.π (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I) =
    Multicofork.π
      (Multicofork.ofSigmaCofork I
        (colimit.cocone (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I))))
      b
Theorem: Set.preimage_iInter
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.224777
ι : Sort u_3
ι' : Sort ?u.224783
ι₂ : Sort ?u.224786
κ : ι → Sort ?u.224791
κ₁ : ι → Sort ?u.224796
κ₂ : ι → Sort ?u.224801
κ' : ι' → Sort ?u.224806
f : α → β
s : ι → Set β
⊢ (f ⁻¹' ⋂ (i : ι), s i) = ⋂ (i : ι), f ⁻¹' s i

tactic: simp
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.224777
ι : Sort u_3
ι' : Sort ?u.224783
ι₂ : Sort ?u.224786
κ : ι → Sort ?u.224791
κ₁ : ι → Sort ?u.224796
κ₂ : ι → Sort ?u.224801
κ' : ι' → Sort ?u.224806
f : α → β
s : ι → Set β
x✝ : α
⊢ (x✝ ∈ f ⁻¹' ⋂ (i : ι), s i) ↔ x✝ ∈ ⋂ (i : ι), f ⁻¹' s i
Theorem: Set.image_mul_left'
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp
state_before: F : Type ?u.124190
α : Type u_1
β : Type ?u.124196
γ : Type ?u.124199
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun b => a⁻¹ * b) '' t = (fun b => a * b) ⁻¹' t
Theorem: Ordinal.principal_mul_one
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: rw [principal_one_iff]
state_before: ⊢ Principal (fun x x_1 => x * x_1) 1

tactic: exact zero_mul _
state_before: ⊢ 0 * 0 = 0
Theorem: Int.natAbs_dvd
File: Std/Data/Int/DivMod.lean

tactic: rw [← e]
state_before: a b : Int
e : a = ↑(natAbs a)
⊢ ↑(natAbs a) ∣ b ↔ a ∣ b

tactic: rw [← Int.neg_dvd, ← e]
state_before: a b : Int
e : a = -↑(natAbs a)
⊢ ↑(natAbs a) ∣ b ↔ a ∣ b
Theorem: Ultrafilter.compl_mem_iff_not_mem
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: rw [← compl_not_mem_iff, compl_compl]
state_before: α : Type u
β : Type v
γ : Type ?u.7567
f g : Ultrafilter α
s t : Set α
p q : α → Prop
⊢ sᶜ ∈ f ↔ ¬s ∈ f
Theorem: Units.mk_semiconjBy
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: unfold SemiconjBy
state_before: M : Type u_1
inst✝ : Monoid M
u : Mˣ
x : M
⊢ SemiconjBy (↑u) x (↑u * x * ↑u⁻¹)

tactic: rw [Units.inv_mul_cancel_right]
state_before: M : Type u_1
inst✝ : Monoid M
u : Mˣ
x : M
⊢ ↑u * x = ↑u * x * ↑u⁻¹ * ↑u
Theorem: Mathlib.Tactic.Ring.pow_one
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
⊢ a ^ 1 = a
Theorem: Multiset.countp_nsmul
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction n <;> simp [*, succ_nsmul', succ_mul, zero_nsmul]
state_before: α : Type u_1
β : Type ?u.300349
γ : Type ?u.300352
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
n : ℕ
⊢ countp p (n • s) = n * countp p s
Theorem: UniqueMul.mulHom_preimage
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: intro a b ha hb ab
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
⊢ UniqueMul (Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A)))
    (Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))) a0 b0

tactic: rw [← hf.eq_iff, ← hf.eq_iff]
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
a b : G
ha : a ∈ Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A))
hb : b ∈ Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0

tactic: rw [← hf.eq_iff, map_mul, map_mul] at ab
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
a b : G
ha : a ∈ Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A))
hb : b ∈ Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))
ab : a * b = a0 * b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0

tactic: exact u (Finset.mem_preimage.mp ha) (Finset.mem_preimage.mp hb) ab
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
a b : G
ha : a ∈ Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A))
hb : b ∈ Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))
ab : ↑f a * ↑f b = ↑f a0 * ↑f b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0
Theorem: Pi.lt_def
File: Mathlib/Order/Basic.lean

tactic: simp (config := { contextual := true }) [lt_iff_le_not_le, Pi.le_def]
state_before: ι✝ : Type ?u.46874
α✝ : Type u
β : Type v
γ : Type w
π : ι✝ → Type ?u.46885
r : α✝ → α✝ → Prop
ι : Type u
α : ι → Type v
inst✝ : (i : ι) → Preorder (α i)
x y : (i : ι) → α i
⊢ x < y ↔ x ≤ y ∧ ∃ i, x i < y i
Theorem: minpoly.map_ne_one
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: by_cases hx : IsIntegral A x
state_before: A : Type u_3
B : Type u_1
B' : Type ?u.27580
inst✝⁷ : CommRing A
inst✝⁶ : Ring B
inst✝⁵ : Ring B'
inst✝⁴ : Algebra A B
inst✝³ : Algebra A B'
x : B
inst✝² : Nontrivial B
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
f : A →+* R
⊢ map f (minpoly A x) ≠ 1

tactic: exact mt ((monic hx).eq_one_of_map_eq_one f) (ne_one A x)
state_before: case pos
A : Type u_3
B : Type u_1
B' : Type ?u.27580
inst✝⁷ : CommRing A
inst✝⁶ : Ring B
inst✝⁵ : Ring B'
inst✝⁴ : Algebra A B
inst✝³ : Algebra A B'
x : B
inst✝² : Nontrivial B
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
f : A →+* R
hx : IsIntegral A x
⊢ map f (minpoly A x) ≠ 1

tactic: rw [eq_zero hx, Polynomial.map_zero]
state_before: case neg
A : Type u_3
B : Type u_1
B' : Type ?u.27580
inst✝⁷ : CommRing A
inst✝⁶ : Ring B
inst✝⁵ : Ring B'
inst✝⁴ : Algebra A B
inst✝³ : Algebra A B'
x : B
inst✝² : Nontrivial B
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
f : A →+* R
hx : ¬IsIntegral A x
⊢ map f (minpoly A x) ≠ 1

tactic: exact zero_ne_one
state_before: case neg
A : Type u_3
B : Type u_1
B' : Type ?u.27580
inst✝⁷ : CommRing A
inst✝⁶ : Ring B
inst✝⁵ : Ring B'
inst✝⁴ : Algebra A B
inst✝³ : Algebra A B'
x : B
inst✝² : Nontrivial B
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
f : A →+* R
hx : ¬IsIntegral A x
⊢ 0 ≠ 1
Theorem: Real.surjOn_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [sin_neg, sin_pi_div_two] using
  intermediate_value_Icc (neg_le_self pi_div_two_pos.le) continuous_sin.continuousOn
state_before: ⊢ SurjOn sin (Icc (-(π / 2)) (π / 2)) (Icc (-1) 1)
Theorem: contDiffWithinAt_of_subsingleton
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [Subsingleton.elim f fun _ => 0]
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type ?u.59708
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
inst✝ : Subsingleton F
⊢ ContDiffWithinAt 𝕜 n f s x

tactic: exact contDiffWithinAt_const
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁰ : NormedAddCommGroup D
inst✝⁹ : NormedSpace 𝕜 D
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type uF
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type uG
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
X : Type ?u.59708
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
inst✝ : Subsingleton F
⊢ ContDiffWithinAt 𝕜 n (fun x => 0) s x
Theorem: CategoryTheory.SimplicialObject.eqToIso_refl
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ eqToIso X h = Iso.refl (X.obj [n].op)

tactic: simp [eqToIso]
state_before: case w
C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ (eqToIso X h).hom = (Iso.refl (X.obj [n].op)).hom
Theorem: modEq_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [one_mul]
state_before: n k : ℕ
⊢ 1 * (k / 2 ^ n) + k % 2 ^ n = k / 2 ^ n + k % 2 ^ n
Theorem: List.size_toArrayAux
File: src/lean/Init/Data/Array/BasicAux.lean

tactic: induction as generalizing bs with
| nil => simp [toArrayAux]
| cons a as ih => simp_arith [toArrayAux, *]
state_before: α : Type u_1
as : List α
bs : Array α
⊢ Array.size (toArrayAux as bs) = length as + Array.size bs

tactic: simp [toArrayAux]
state_before: case nil
α : Type u_1
bs : Array α
⊢ Array.size (toArrayAux [] bs) = length [] + Array.size bs

tactic: simp_arith [toArrayAux, *]
state_before: case cons
α : Type u_1
a : α
as : List α
ih : ∀ (bs : Array α), Array.size (toArrayAux as bs) = length as + Array.size bs
bs : Array α
⊢ Array.size (toArrayAux (a :: as) bs) = length (a :: as) + Array.size bs
Theorem: Finset.coe_eq_pair
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_pair, coe_inj]
state_before: α : Type u_1
β : Type ?u.109653
γ : Type ?u.109656
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ : α
s : Finset α
a b : α
⊢ ↑s = {a, b} ↔ s = {a, b}
Theorem: Matrix.isAdjMatrix_compl
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [h]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.16625
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
h : IsSymm A
⊢ IsSymm (compl A)
Theorem: Equiv.apply_eq_iff_eq_symm_apply
File: Mathlib/Logic/Equiv/Defs.lean

tactic: conv_lhs => rw [← apply_symm_apply f y]
state_before: α : Sort u
β : Sort v
γ : Sort w
x : α
y : (fun x => β) x
f : α ≃ β
⊢ ↑f x = y ↔ x = ↑f.symm y

tactic: rw [apply_eq_iff_eq]
state_before: α : Sort u
β : Sort v
γ : Sort w
x : α
y : (fun x => β) x
f : α ≃ β
⊢ ↑f x = ↑f (↑f.symm y) ↔ x = ↑f.symm y
Theorem: Fin.insertNth_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: refine' insertNth_eq_iff.2 ⟨by simp, _⟩
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (↑(succAbove 0) j)
⊢ insertNth 0 x p = cons x fun j => _root_.cast (_ : α (↑(succAbove 0) j) = α (succ j)) (p j)

tactic: ext j
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (↑(succAbove 0) j)
⊢ p = fun j => cons x (fun j => _root_.cast (_ : α (↑(succAbove 0) j) = α (succ j)) (p j)) (↑(succAbove 0) j)

tactic: convert (cons_succ x p j).symm
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (↑(succAbove 0) j)
j : Fin n
⊢ p j = cons x (fun j => _root_.cast (_ : α (↑(succAbove 0) j) = α (succ j)) (p j)) (↑(succAbove 0) j)

tactic: simp
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α 0
p : (j : Fin n) → α (↑(succAbove 0) j)
⊢ cons x (fun j => _root_.cast (_ : α (↑(succAbove 0) j) = α (succ j)) (p j)) 0 = x
Theorem: Finset.univ_inter
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.21194
γ : Type ?u.21197
inst✝¹ : Fintype α
s✝ t : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
⊢ a ∈ univ ∩ s ↔ a ∈ s
Theorem: List.product_nil
File: Mathlib/Data/List/ProdSigma.lean

tactic: simp [product_cons, product_nil]
state_before: α : Type u_1
β : Type u_2
head✝ : α
l : List α
⊢ (head✝ :: l) ×ˢ [] = []
Theorem: Quiver.hom_cast_eq_of_cons_eq_cons
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Hom.cast_eq_iff_heq]
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : cons p e = cons p' e'
⊢ Hom.cast (_ : v = v') (_ : w = w) e = e'

tactic: exact hom_heq_of_cons_eq_cons h
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : cons p e = cons p' e'
⊢ HEq e e'
Theorem: IsCoprime.of_add_mul_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

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

tactic: exact h.of_add_mul_left_left
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime (y + x * z) x
⊢ IsCoprime y x
Theorem: IsGδ.dense_sUnion_interior_of_closed
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: rwa [← sUnion_eq_biUnion]
state_before: α : Type u_1
β : Type ?u.27075
γ : Type ?u.27078
ι : Type ?u.27081
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
T : Set (Set α)
s : Set α
hs : IsGδ s
hd : Dense s
hc : Set.Countable T
hc' : ∀ (t : Set α), t ∈ T → IsClosed t
hU : s ⊆ ⋃₀ T
⊢ s ⊆ ⋃ (i : Set α) (_ : i ∈ T), i