tasksource/leandojo huggingface dataset:
Theorem: StructureGroupoid.LocalInvariantProp.liftPropWithinAt_mono_of_mem
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: refine' ⟨h.1.mono_of_mem hst, mono_of_mem _ h.2⟩
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.47928
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
mono_of_mem : ∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, s ∈ 𝓝[t] x → P f s x → P f t x
h : LiftPropWithinAt P g s x
hst : s ∈ 𝓝[t] x
⊢ LiftPropWithinAt P g t x

tactic: simp_rw [← mem_map, (chartAt H x).symm.map_nhdsWithin_preimage_eq (mem_chart_target H x),
  (chartAt H x).left_inv (mem_chart_source H x), hst]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.47928
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
mono_of_mem : ∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, s ∈ 𝓝[t] x → P f s x → P f t x
h : LiftPropWithinAt P g s x
hst : s ∈ 𝓝[t] x
⊢ ↑(LocalHomeomorph.symm (chartAt H x)) ⁻¹' s ∈ 𝓝[↑(LocalHomeomorph.symm (chartAt H x)) ⁻¹' t] ↑(chartAt H x) x
Theorem: Class.mem_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: refine' ⟨fun hy z => mem_of_mem_sInter hy, fun H => _⟩
state_before: x y : Class
h : Set.Nonempty x
⊢ y ∈ ⋂₀ x ↔ ∀ (z : Class), z ∈ x → y ∈ z

tactic: simp_rw [mem_def, sInter_apply]
state_before: x y : Class
h : Set.Nonempty x
H : ∀ (z : Class), z ∈ x → y ∈ z
⊢ y ∈ ⋂₀ x

tactic: obtain ⟨z, hz⟩ := h
state_before: x y : Class
h : Set.Nonempty x
H : ∀ (z : Class), z ∈ x → y ∈ z
⊢ ∃ x_1, ↑x_1 = y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z

tactic: obtain ⟨y, rfl, _⟩ := H z (coe_mem.2 hz)
state_before: case intro
x y : Class
H : ∀ (z : Class), z ∈ x → y ∈ z
z : ZFSet
hz : z ∈ x
⊢ ∃ x_1, ↑x_1 = y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z

tactic: refine' ⟨y, rfl, fun w hxw => _⟩
state_before: case intro.intro.intro
x : Class
z : ZFSet
hz : z ∈ x
y : ZFSet
right✝ : ↑z y
H : ∀ (z : Class), z ∈ x → ↑y ∈ z
⊢ ∃ x_1, ↑x_1 = ↑y ∧ ∀ (z : ZFSet), x z → x_1 ∈ z

tactic: simpa only [coe_mem, coe_apply] using H w (coe_mem.2 hxw)
state_before: case intro.intro.intro
x : Class
z : ZFSet
hz : z ∈ x
y : ZFSet
right✝ : ↑z y
H : ∀ (z : Class), z ∈ x → ↑y ∈ z
w : ZFSet
hxw : x w
⊢ y ∈ w
Theorem: PartENat.withTopEquiv_zero
File: Mathlib/Data/Nat/PartENat.lean

tactic: simpa only [Nat.cast_zero] using withTopEquiv_natCast 0
state_before: ⊢ ↑withTopEquiv 0 = 0
Theorem: Finset.max_eq_bot
File: Mathlib/Data/Finset/Lattice.lean

tactic: obtain ⟨a, ha⟩ := max_of_nonempty H
state_before: F : Type ?u.314269
α : Type u_1
β : Type ?u.314275
γ : Type ?u.314278
ι : Type ?u.314281
κ : Type ?u.314284
inst✝ : LinearOrder α
s : Finset α
h : Finset.max s = ⊥
H : Finset.Nonempty s
⊢ s = ∅

tactic: rw [h] at ha
state_before: case intro
F : Type ?u.314269
α : Type u_1
β : Type ?u.314275
γ : Type ?u.314278
ι : Type ?u.314281
κ : Type ?u.314284
inst✝ : LinearOrder α
s : Finset α
h : Finset.max s = ⊥
H : Finset.Nonempty s
a : α
ha : Finset.max s = ↑a
⊢ s = ∅

tactic: cases ha
state_before: case intro
F : Type ?u.314269
α : Type u_1
β : Type ?u.314275
γ : Type ?u.314278
ι : Type ?u.314281
κ : Type ?u.314284
inst✝ : LinearOrder α
s : Finset α
h : Finset.max s = ⊥
H : Finset.Nonempty s
a : α
ha : ⊥ = ↑a
⊢ s = ∅
Theorem: Set.image_const_add_Ioc
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: simp only [add_comm a, image_add_const_Ioc]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ioc b c = Ioc (a + b) (a + c)
Theorem: Matrix.map_one
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.76780
m : Type ?u.76783
n : Type u_1
o : Type ?u.76789
m' : o → Type ?u.76794
n' : o → Type ?u.76799
R : Type ?u.76802
S : Type ?u.76805
α : Type v
β : Type w
γ : Type ?u.76812
inst✝⁴ : DecidableEq n
inst✝³ : Zero α
inst✝² : One α
inst✝¹ : Zero β
inst✝ : One β
f : α → β
h₀ : f 0 = 0
h₁ : f 1 = 1
⊢ map 1 f = 1

tactic: simp only [one_apply, map_apply]
state_before: case a.h
l : Type ?u.76780
m : Type ?u.76783
n : Type u_1
o : Type ?u.76789
m' : o → Type ?u.76794
n' : o → Type ?u.76799
R : Type ?u.76802
S : Type ?u.76805
α : Type v
β : Type w
γ : Type ?u.76812
inst✝⁴ : DecidableEq n
inst✝³ : Zero α
inst✝² : One α
inst✝¹ : Zero β
inst✝ : One β
f : α → β
h₀ : f 0 = 0
h₁ : f 1 = 1
i✝ x✝ : n
⊢ map 1 f i✝ x✝ = OfNat.ofNat 1 i✝ x✝

tactic: split_ifs <;> simp [h₀, h₁]
state_before: case a.h
l : Type ?u.76780
m : Type ?u.76783
n : Type u_1
o : Type ?u.76789
m' : o → Type ?u.76794
n' : o → Type ?u.76799
R : Type ?u.76802
S : Type ?u.76805
α : Type v
β : Type w
γ : Type ?u.76812
inst✝⁴ : DecidableEq n
inst✝³ : Zero α
inst✝² : One α
inst✝¹ : Zero β
inst✝ : One β
f : α → β
h₀ : f 0 = 0
h₁ : f 1 = 1
i✝ x✝ : n
⊢ f (if i✝ = x✝ then 1 else 0) = if i✝ = x✝ then 1 else 0
Theorem: Polynomial.Separable.map
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [derivative_map, ← Polynomial.map_mul, ← Polynomial.map_mul, ← Polynomial.map_add, H,
  Polynomial.map_one]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p : R[X]
h : Separable p
f : R →+* S
a b : R[X]
H : a * p + b * ↑derivative p = 1
⊢ Polynomial.map f a * Polynomial.map f p + Polynomial.map f b * ↑derivative (Polynomial.map f p) = 1
Theorem: CategoryTheory.Limits.kernelSubobjectIso_comp_kernel_map
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [← Iso.comp_inv_eq, kernel_map_comp_kernelSubobjectIso_inv]
state_before: C : Type u
inst✝³ : Category C
X Y Z : C
inst✝² : HasZeroMorphisms C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
sq : Arrow.mk f ⟶ Arrow.mk f'
⊢ (kernelSubobjectIso f).hom ≫
      kernel.map f f' sq.left sq.right
        (_ : (Arrow.mk f).hom ≫ (𝟭 C).map sq.right = (𝟭 C).map sq.left ≫ (Arrow.mk f').hom) =
    kernelSubobjectMap sq ≫ (kernelSubobjectIso f').hom
Theorem: eq_orthogonalProjection_of_mem_orthogonal'
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: simpa [hu]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.799854
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
u v z : E
hv : v ∈ K
hz : z ∈ Kᗮ
hu : u = v + z
⊢ u - v ∈ Kᗮ
Theorem: AffineSubspace.coe_direction_eq_vsub_set_right
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [coe_direction_eq_vsub_set ⟨p, hp⟩]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
⊢ ↑(direction s) = (fun x => x -ᵥ p) '' ↑s

tactic: refine' le_antisymm _ _
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
⊢ ↑s -ᵥ ↑s = (fun x => x -ᵥ p) '' ↑s

tactic: rintro v ⟨p1, p2, hp1, hp2, rfl⟩
state_before: case refine'_1
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
⊢ ↑s -ᵥ ↑s ≤ (fun x => x -ᵥ p) '' ↑s

tactic: exact ⟨p1 -ᵥ p2 +ᵥ p, vadd_mem_of_mem_direction (vsub_mem_direction hp1 hp2) hp, vadd_vsub _ _⟩
state_before: case refine'_1.intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p1 p2 : P
hp1 : p1 ∈ ↑s
hp2 : p2 ∈ ↑s
⊢ (fun x x_1 => x -ᵥ x_1) p1 p2 ∈ (fun x => x -ᵥ p) '' ↑s

tactic: rintro v ⟨p2, hp2, rfl⟩
state_before: case refine'_2
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
⊢ (fun x => x -ᵥ p) '' ↑s ≤ ↑s -ᵥ ↑s

tactic: exact ⟨p2, p, hp2, hp, rfl⟩
state_before: case refine'_2.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p2 : P
hp2 : p2 ∈ ↑s
⊢ (fun x => x -ᵥ p) p2 ∈ ↑s -ᵥ ↑s
Theorem: Submonoid.prod_top
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp [mem_prod, MonoidHom.coe_fst]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.98294
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.98315
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
x : M × N
⊢ x ∈ prod s ⊤ ↔ x ∈ comap (MonoidHom.fst M N) s
Theorem: Set.image_univ_of_surjective
File: Mathlib/Data/Set/Image.lean

tactic: simpa [image]
state_before: α : Type ?u.32858
β : Type u_2
γ : Type ?u.32864
ι✝ : Sort ?u.32867
ι' : Sort ?u.32870
f✝ : α → β
s t : Set α
ι : Type u_1
f : ι → β
H : Surjective f
⊢ ∀ (x : β), x ∈ f '' univ
Theorem: dist_div_norm_sq_smul
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [dist_eq_norm, sqrt_sq (norm_nonneg _)]
state_before: 𝕜 : Type ?u.2668535
E : Type ?u.2668538
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
hx : x ≠ 0
hy : y ≠ 0
R : ℝ
hx' : ‖x‖ ≠ 0
hy' : ‖y‖ ≠ 0
⊢ dist ((R / ‖x‖) ^ 2 • x) ((R / ‖y‖) ^ 2 • y) = sqrt (‖(R / ‖x‖) ^ 2 • x - (R / ‖y‖) ^ 2 • y‖ ^ 2)

tactic: field_simp [sq, norm_sub_mul_self_real, norm_smul, real_inner_smul_left, inner_smul_right,
  Real.norm_of_nonneg (mul_self_nonneg _)]
state_before: 𝕜 : Type ?u.2668535
E : Type ?u.2668538
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
hx : x ≠ 0
hy : y ≠ 0
R : ℝ
hx' : ‖x‖ ≠ 0
hy' : ‖y‖ ≠ 0
⊢ ‖(R / ‖x‖) ^ 2 • x - (R / ‖y‖) ^ 2 • y‖ ^ 2 = (R ^ 2 / (‖x‖ * ‖y‖)) ^ 2 * ‖x - y‖ ^ 2

tactic: ring
state_before: 𝕜 : Type ?u.2668535
E : Type ?u.2668538
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
hx : x ≠ 0
hy : y ≠ 0
R : ℝ
hx' : ‖x‖ ≠ 0
hy' : ‖y‖ ≠ 0
⊢ ((R * R * ‖x‖ * (R * R * ‖x‖) * (‖y‖ * ‖y‖ * (‖x‖ * ‖x‖)) -
            ‖x‖ * ‖x‖ * (‖x‖ * ‖x‖) * (2 * (R * R * (R * R * inner x y)))) *
          (‖y‖ * ‖y‖ * (‖y‖ * ‖y‖)) +
        R * R * ‖y‖ * (R * R * ‖y‖) * (‖x‖ * ‖x‖ * (‖x‖ * ‖x‖) * (‖y‖ * ‖y‖ * (‖x‖ * ‖x‖)))) *
      (‖x‖ * ‖y‖ * (‖x‖ * ‖y‖)) =
    R * R * (R * R) * (‖x‖ * ‖x‖ - 2 * inner x y + ‖y‖ * ‖y‖) *
      (‖x‖ * ‖x‖ * (‖x‖ * ‖x‖) * (‖y‖ * ‖y‖ * (‖x‖ * ‖x‖)) * (‖y‖ * ‖y‖ * (‖y‖ * ‖y‖)))

tactic: rw [sqrt_mul (sq_nonneg _), sqrt_sq (norm_nonneg _),
  sqrt_sq (div_nonneg (sq_nonneg _) (mul_nonneg (norm_nonneg _) (norm_nonneg _))),
  dist_eq_norm]
state_before: 𝕜 : Type ?u.2668535
E : Type ?u.2668538
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
hx : x ≠ 0
hy : y ≠ 0
R : ℝ
hx' : ‖x‖ ≠ 0
hy' : ‖y‖ ≠ 0
⊢ sqrt ((R ^ 2 / (‖x‖ * ‖y‖)) ^ 2 * ‖x - y‖ ^ 2) = R ^ 2 / (‖x‖ * ‖y‖) * dist x y
Theorem: mul_ball
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [← smul_ball_one, mul_smul_comm, mul_ball_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s * ball x δ = x • thickening δ s
Theorem: List.map_map
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l <;> simp_all
state_before: β : Type u_1
γ : Type u_2
α : Type u_3
g : β → γ
f : α → β
l : List α
⊢ map g (map f l) = map (g ∘ f) l
Theorem: CategoryTheory.Functor.initial_of_adjunction
File: Mathlib/CategoryTheory/Limits/Final.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
d : D
u : CostructuredArrow L d := CostructuredArrow.mk (adj.counit.app d)
f g : CostructuredArrow L d
⊢ L.map (↑(Adjunction.homEquiv adj f.left d) f.hom) ≫ u.hom = f.hom

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
d : D
u : CostructuredArrow L d := CostructuredArrow.mk (adj.counit.app d)
f g : CostructuredArrow L d
⊢ L.map (↑(Adjunction.homEquiv adj g.left d) g.hom) ≫ u.hom = g.hom
Theorem: Finset.exists_le_card_fiber_of_nsmul_le_card_of_maps_to
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simp_rw [cast_card] at hb⊢
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : Finset.Nonempty t
hb : card t • b ≤ ↑(card s)
⊢ ∃ y, y ∈ t ∧ b ≤ ↑(card (filter (fun x => f x = y) s))

tactic: exact exists_le_sum_fiber_of_maps_to_of_nsmul_le_sum hf ht hb
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ (a : α), a ∈ s → f a ∈ t
ht : Finset.Nonempty t
hb : card t • b ≤ ∑ a in s, 1
⊢ ∃ y, y ∈ t ∧ b ≤ ∑ a in filter (fun x => f x = y) s, 1
Theorem: Cardinal.toPartENat_cast
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [toPartENat_apply_of_lt_aleph0 (nat_lt_aleph0 n), toNat_cast]
state_before: α β : Type u
n : ℕ
⊢ ↑toPartENat ↑n = ↑n
Theorem: Real.hasDerivWithinAt_arcsin_Ici
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

tactic: rcases eq_or_ne x 1 with (rfl | h')
state_before: x : ℝ
h : x ≠ -1
⊢ HasDerivWithinAt arcsin (1 / sqrt (1 - x ^ 2)) (Ici x) x

tactic: convert (hasDerivWithinAt_const (1 : ℝ) _ (π / 2)).congr _ _ <;>
  simp (config := { contextual := true }) [arcsin_of_one_le]
state_before: case inl
h : 1 ≠ -1
⊢ HasDerivWithinAt arcsin (1 / sqrt (1 - 1 ^ 2)) (Ici 1) 1

tactic: exact (hasDerivAt_arcsin h h').hasDerivWithinAt
state_before: case inr
x : ℝ
h : x ≠ -1
h' : x ≠ 1
⊢ HasDerivWithinAt arcsin (1 / sqrt (1 - x ^ 2)) (Ici x) x
Theorem: Lagrange.eval_basis_of_ne
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [Lagrange.basis, eval_prod, prod_eq_zero_iff]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
hj : j ∈ s
⊢ eval (v j) (Lagrange.basis s v i) = 0

tactic: exact ⟨j, ⟨mem_erase.mpr ⟨hij.symm, hj⟩, eval_basisDivisor_right⟩⟩
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
hj : j ∈ s
⊢ ∃ a, a ∈ Finset.erase s i ∧ eval (v j) (basisDivisor (v i) (v a)) = 0
Theorem: Finset.inter_singleton_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, singleton_inter_of_mem h]
state_before: α : Type u_1
β : Type ?u.188015
γ : Type ?u.188018
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a✝ b a : α
s : Finset α
h : a ∈ s
⊢ s ∩ {a} = {a}
Theorem: String.Iterator.ValidFor.remainingToString
File: Std/Data/String/Lemmas.lean

tactic: cases h.out
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ Iterator.remainingToString it = { data := r }

tactic: simpa [Iterator.remainingToString, List.reverseAux_eq] using extract_of_valid l.reverse r []
state_before: case refl
l r : List Char
h : ValidFor l r { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } }
⊢ Iterator.remainingToString { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } = { data := r }
Theorem: CategoryTheory.Limits.ι_colimitLimitToLimitColimit_π
File: Mathlib/CategoryTheory/Limits/ColimitLimit.lean

tactic: dsimp [colimitLimitToLimitColimit]
state_before: J K : Type v
inst✝⁴ : SmallCategory J
inst✝³ : SmallCategory K
C : Type u
inst✝² : Category C
F : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
j : J
k : K
⊢ colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k ≫ colimitLimitToLimitColimit F ≫ limit.π (curry.obj F ⋙ colim) j =
    limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k

tactic: simp
state_before: J K : Type v
inst✝⁴ : SmallCategory J
inst✝³ : SmallCategory K
C : Type u
inst✝² : Category C
F : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
j : J
k : K
⊢ colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k ≫
      limit.lift (curry.obj F ⋙ colim)
          { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
            π :=
              NatTrans.mk fun j =>
                colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                  { pt := colimit ((curry.obj F).obj j),
                    ι :=
                      NatTrans.mk fun k =>
                        limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k } } ≫
        limit.π (curry.obj F ⋙ colim) j =
    limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k
Theorem: CategoryTheory.preserves_lift_mapCone
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: simp [← G.map_comp]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
G : C ⥤ D
J : Type w
inst✝¹ : Category J
F : J ⥤ C
inst✝ : PreservesLimit F G
c₁ c₂ : Cone F
t : IsLimit c₁
⊢ ∀ (j : J), G.map (IsLimit.lift t c₂) ≫ (G.mapCone c₁).π.app j = (G.mapCone c₂).π.app j
Theorem: Localization.add_mk_self
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [add_mk, mk_eq_mk_iff, r_eq_r']
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type ?u.2768138
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type ?u.2768305
inst✝ : CommSemiring P
a : R
b : { x // x ∈ M }
c : R
⊢ mk a b + mk c b = mk (a + c) b

tactic: refine' (r' M).symm ⟨1, _⟩
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type ?u.2768138
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type ?u.2768305
inst✝ : CommSemiring P
a : R
b : { x // x ∈ M }
c : R
⊢ ↑(r' M) (↑b * c + ↑b * a, b * b) (a + c, b)

tactic: simp only [Submonoid.coe_one, Submonoid.coe_mul]
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type ?u.2768138
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type ?u.2768305
inst✝ : CommSemiring P
a : R
b : { x // x ∈ M }
c : R
⊢ ↑1 * (↑(↑b * c + ↑b * a, b * b).snd * (a + c, b).fst) = ↑1 * (↑(a + c, b).snd * (↑b * c + ↑b * a, b * b).fst)

tactic: ring
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type ?u.2768138
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type ?u.2768305
inst✝ : CommSemiring P
a : R
b : { x // x ∈ M }
c : R
⊢ 1 * (↑b * ↑b * (a + c)) = 1 * (↑b * (↑b * c + ↑b * a))
Theorem: zpow_bit0
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp only [zpow_ofNat, ← Int.ofNat_bit0, pow_bit0]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
n : ℕ
⊢ a ^ bit0 ↑n = a ^ ↑n * a ^ ↑n

tactic: simp [← mul_inv_rev, ← pow_bit0]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
n : ℕ
⊢ a ^ bit0 -[n+1] = a ^ -[n+1] * a ^ -[n+1]

tactic: rw [negSucc_eq, bit0_neg, zpow_neg]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
n : ℕ
⊢ a ^ bit0 -[n+1] = (a ^ bit0 (n + 1))⁻¹

tactic: norm_cast
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
n : ℕ
⊢ (a ^ bit0 (↑n + 1))⁻¹ = (a ^ bit0 (n + 1))⁻¹
Theorem: Stream'.Seq.tail_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: cases' s with f al
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : Seq α
⊢ tail (cons a s) = s

tactic: apply Subtype.eq
state_before: case mk
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : IsSeq f
⊢ tail (cons a { val := f, property := al }) = { val := f, property := al }

tactic: dsimp [tail, cons]
state_before: case mk.a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : IsSeq f
⊢ ↑(tail (cons a { val := f, property := al })) = ↑{ val := f, property := al }
Theorem: abs_dist_sub_le_dist_mul_mul
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [dist_mul_left, dist_mul_right, dist_comm b₂] using
  abs_dist_sub_le (a₁ * a₂) (b₁ * b₂) (b₁ * a₂)
state_before: 𝓕 : Type ?u.649048
𝕜 : Type ?u.649051
α : Type ?u.649054
ι : Type ?u.649057
κ : Type ?u.649060
E : Type u_1
F : Type ?u.649066
G : Type ?u.649069
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁✝ a₂✝ b b₁✝ b₂✝ : E
r r₁ r₂ : ℝ
a₁ a₂ b₁ b₂ : E
⊢ abs (dist a₁ b₁ - dist a₂ b₂) ≤ dist (a₁ * a₂) (b₁ * b₂)
Theorem: Polynomial.natDegree_eq_zero_iff_degree_le_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← nonpos_iff_eq_zero, natDegree_le_iff_degree_le,
  Nat.cast_withBot, WithBot.coe_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.701471
⊢ natDegree p = 0 ↔ degree p ≤ 0
Theorem: List.nthLe_insertNth_add_succ
File: Mathlib/Data/List/Basic.lean

tactic: rw [length_insertNth _ _ (le_self_add.trans hk'.le)]
state_before: ι : Type ?u.128455
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n k : ℕ
hk' : n + k < length l
⊢ n + k + 1 < length (insertNth n x l)

tactic: exact Nat.succ_lt_succ_iff.2 hk'
state_before: ι : Type ?u.128455
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n k : ℕ
hk' : n + k < length l
⊢ n + k + 1 < length l + 1
Theorem: Cubic.c_eq_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: injection eq_sum_three_roots ha h3
state_before: R : Type ?u.1067442
S : Type ?u.1067445
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ ↑φ P.c = ↑φ P.a * (x * y + x * z + y * z)
Theorem: toIocDiv_sub'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocDiv_sub_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp (a - p) b = toIocDiv hp a b + 1