tasksource/leandojo huggingface dataset:
Theorem: collinear_insert_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_insert_iff_of_mem_affineSpan h]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.322022
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₁, p₂, p₃}

tactic: exact collinear_pair _ _ _
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.322022
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₂, p₃}
Theorem: slope_comm
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

tactic: rw [slope, slope, ← neg_vsub_eq_vsub_rev, smul_neg, ← neg_smul, neg_inv, neg_sub]
state_before: k : Type u_2
E : Type u_1
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b : k
⊢ slope f a b = slope f b a
Theorem: List.pairwise_iff_coe_toFinset_pairwise
File: Mathlib/Data/Finset/Pairwise.lean

tactic: letI : IsSymm α r := ⟨hs⟩
state_before: α : Type u_1
ι : Type ?u.7414
ι' : Type ?u.7417
β : Type ?u.7420
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hn : Nodup l
hs : Symmetric r
⊢ Set.Pairwise (↑(toFinset l)) r ↔ Pairwise r l

tactic: rw [coe_toFinset, hn.pairwise_coe]
state_before: α : Type u_1
ι : Type ?u.7414
ι' : Type ?u.7417
β : Type ?u.7420
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hn : Nodup l
hs : Symmetric r
this : IsSymm α r := { symm := hs }
⊢ Set.Pairwise (↑(toFinset l)) r ↔ Pairwise r l
Theorem: Function.Periodic.sub_antiperiod
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg] using h1.add_antiperiod h2.neg
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.215561
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Periodic f c₁
h2 : Antiperiodic f c₂
⊢ Antiperiodic f (c₁ - c₂)
Theorem: algebraicIndependent_iUnion_of_directed
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: refine' algebraicIndependent_of_finite (⋃ i, s i) fun t ht ft => _
state_before: ι : Type ?u.871631
ι' : Type ?u.871634
R : Type u_3
K : Type ?u.871640
A : Type u_2
A' : Type ?u.871646
A'' : Type ?u.871649
V : Type u
V' : Type ?u.871654
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
η : Type u_1
inst✝ : Nonempty η
s : η → Set A
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), AlgebraicIndependent R Subtype.val
⊢ AlgebraicIndependent R Subtype.val

tactic: rcases finite_subset_iUnion ft ht with ⟨I, fi, hI⟩
state_before: ι : Type ?u.871631
ι' : Type ?u.871634
R : Type u_3
K : Type ?u.871640
A : Type u_2
A' : Type ?u.871646
A'' : Type ?u.871649
V : Type u
V' : Type ?u.871654
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
η : Type u_1
inst✝ : Nonempty η
s : η → Set A
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), AlgebraicIndependent R Subtype.val
t : Set A
ht : t ⊆ ⋃ (i : η), s i
ft : Set.Finite t
⊢ AlgebraicIndependent R Subtype.val

tactic: rcases hs.finset_le fi.toFinset with ⟨i, hi⟩
state_before: case intro.intro
ι : Type ?u.871631
ι' : Type ?u.871634
R : Type u_3
K : Type ?u.871640
A : Type u_2
A' : Type ?u.871646
A'' : Type ?u.871649
V : Type u
V' : Type ?u.871654
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
η : Type u_1
inst✝ : Nonempty η
s : η → Set A
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), AlgebraicIndependent R Subtype.val
t : Set A
ht : t ⊆ ⋃ (i : η), s i
ft : Set.Finite t
I : Set η
fi : Set.Finite I
hI : t ⊆ ⋃ (i : η) (_ : i ∈ I), s i
⊢ AlgebraicIndependent R Subtype.val

tactic: exact (h i).mono (Subset.trans hI <| iUnion₂_subset fun j hj => hi j (fi.mem_toFinset.2 hj))
state_before: case intro.intro.intro
ι : Type ?u.871631
ι' : Type ?u.871634
R : Type u_3
K : Type ?u.871640
A : Type u_2
A' : Type ?u.871646
A'' : Type ?u.871649
V : Type u
V' : Type ?u.871654
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
η : Type u_1
inst✝ : Nonempty η
s : η → Set A
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), AlgebraicIndependent R Subtype.val
t : Set A
ht : t ⊆ ⋃ (i : η), s i
ft : Set.Finite t
I : Set η
fi : Set.Finite I
hI : t ⊆ ⋃ (i : η) (_ : i ∈ I), s i
i : η
hi : ∀ (i_1 : η), i_1 ∈ Finite.toFinset fi → s i_1 ⊆ s i
⊢ AlgebraicIndependent R Subtype.val
Theorem: MeasureTheory.Measure.finset_sum_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [coe_finset_sum, Finset.sum_apply]
state_before: α : Type u_1
β : Type ?u.122815
γ : Type ?u.122818
δ : Type ?u.122821
ι : Type u_2
R : Type ?u.122827
R' : Type ?u.122830
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
m : MeasurableSpace α
I : Finset ι
μ : ι → Measure α
s : Set α
⊢ ↑↑(∑ i in I, μ i) s = ∑ i in I, ↑↑(μ i) s
Theorem: FirstOrder.Language.Substructure.mem_iInf
File: Mathlib/ModelTheory/Substructures.lean

tactic: simp only [iInf, mem_sInf, Set.forall_range_iff]
state_before: L : Language
M : Type w
N : Type ?u.19040
P : Type ?u.19043
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S✝ : Substructure L M
ι : Sort u_1
S : ι → Substructure L M
x : M
⊢ (x ∈ ⨅ (i : ι), S i) ↔ ∀ (i : ι), x ∈ S i
Theorem: isAlgebraic_algebraMap_of_isAlgebraic
File: Mathlib/RingTheory/Algebraic.lean

tactic: rw [aeval_algebraMap_apply, hf₂, map_zero]
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : Algebra R S
inst✝¹ : Algebra S A
inst✝ : IsScalarTower R S A
a : S
x✝ : IsAlgebraic R a
f : R[X]
hf₁ : f ≠ 0
hf₂ : ↑(aeval a) f = 0
⊢ ↑(aeval (↑(algebraMap S A) a)) f = 0
Theorem: Matrix.row_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
x : α
u : Fin m → α
⊢ row (vecCons x u) = fun x_1 => vecCons x u

tactic: rfl
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
x : α
u : Fin m → α
i✝ : Unit
x✝ : Fin (Nat.succ m)
⊢ row (vecCons x u) i✝ x✝ = vecCons x u x✝
Theorem: forall_eq_apply_imp_iff'
File: Mathlib/Logic/Basic.lean

tactic: simp [forall_swap]
state_before: ι : Sort ?u.19831
α : Sort ?u.19836
κ : ι → Sort ?u.19833
p✝ q : α → Prop
β : Sort u_1
f : α → β
p : β → Prop
⊢ (∀ (b : β) (a : α), b = f a → p b) ↔ ∀ (a : α), p (f a)
Theorem: Sym2.other_mem
File: Mathlib/Data/Sym/Sym2.lean

tactic: convert mem_mk''_right a <| Mem.other h
state_before: α : Type u_1
β : Type ?u.35146
γ : Type ?u.35149
a : α
z : Sym2 α
h : a ∈ z
⊢ Mem.other h ∈ z

tactic: rw [other_spec h]
state_before: case h.e'_5
α : Type u_1
β : Type ?u.35146
γ : Type ?u.35149
a : α
z : Sym2 α
h : a ∈ z
⊢ z = Quotient.mk (Rel.setoid α) (a, Mem.other h)
Theorem: Subspace.dualLift_of_mem
File: Mathlib/LinearAlgebra/Dual.lean

tactic: convert dualLift_of_subtype ⟨w, hw⟩
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
φ : Module.Dual K { x // x ∈ W }
w : V
hw : w ∈ W
⊢ ↑(↑(dualLift W) φ) w = ↑φ { val := w, property := hw }
Theorem: conjugate_nonneg'
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa only [star_star] using conjugate_nonneg ha (star c)
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha : 0 ≤ a
c : R
⊢ 0 ≤ c * a * star c
Theorem: smul_sub
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, smul_add, smul_neg]
state_before: M : Type u_2
N : Type ?u.62983
G : Type ?u.62986
A : Type u_1
B : Type ?u.62992
α : Type ?u.62995
β : Type ?u.62998
γ : Type ?u.63001
δ : Type ?u.63004
inst✝² : Monoid M
inst✝¹ : AddGroup A
inst✝ : DistribMulAction M A
r : M
x y : A
⊢ r • (x - y) = r • x - r • y
Theorem: PEquiv.self_trans_symm
File: Mathlib/Data/PEquiv.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ PEquiv.trans f (PEquiv.symm f) = ofSet {a | isSome (↑f a) = true}

tactic: dsimp [PEquiv.trans]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ a✝ : α
⊢ a✝ ∈ ↑(PEquiv.trans f (PEquiv.symm f)) x✝ ↔ a✝ ∈ ↑(ofSet {a | isSome (↑f a) = true}) x✝

tactic: simp only [eq_some_iff f, Option.isSome_iff_exists, Option.mem_def, bind_eq_some',
  ofSet_eq_some_iff]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ a✝ : α
⊢ a✝ ∈ Option.bind (↑f x✝) ↑(PEquiv.symm f) ↔ a✝ ∈ ↑(ofSet {a | isSome (↑f a) = true}) x✝

tactic: constructor
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ a✝ : α
⊢ (∃ a, ↑f x✝ = some a ∧ ↑f a✝ = some a) ↔ a✝ = x✝ ∧ a✝ ∈ {a | ∃ a_1, ↑f a = some a_1}

tactic: rintro ⟨b, hb₁, hb₂⟩
state_before: case h.a.mp
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ a✝ : α
⊢ (∃ a, ↑f x✝ = some a ∧ ↑f a✝ = some a) → a✝ = x✝ ∧ a✝ ∈ {a | ∃ a_1, ↑f a = some a_1}

tactic: exact ⟨PEquiv.inj _ hb₂ hb₁, b, hb₂⟩
state_before: case h.a.mp.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ a✝ : α
b : β
hb₁ : ↑f x✝ = some b
hb₂ : ↑f a✝ = some b
⊢ a✝ = x✝ ∧ a✝ ∈ {a | ∃ a_1, ↑f a = some a_1}

tactic: simp (config := { contextual := true })
state_before: case h.a.mpr
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ a✝ : α
⊢ a✝ = x✝ ∧ a✝ ∈ {a | ∃ a_1, ↑f a = some a_1} → ∃ a, ↑f x✝ = some a ∧ ↑f a✝ = some a
Theorem: ofBoolAlg_symmDiff
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: α : Type u_1
β : Type ?u.38685
γ : Type ?u.38688
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : AsBoolAlg α
⊢ ↑ofBoolAlg (a ∆ b) = ↑ofBoolAlg a + ↑ofBoolAlg b

tactic: exact of_boolalg_symm_diff_aux _ _
state_before: α : Type u_1
β : Type ?u.38685
γ : Type ?u.38688
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : AsBoolAlg α
⊢ ↑ofBoolAlg ((a ⊔ b) \ (a ⊓ b)) = ↑ofBoolAlg a + ↑ofBoolAlg b
Theorem: iUnion_Icc_int_cast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [zero_add] using iUnion_Icc_add_int_cast (0 : α)
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ (⋃ (n : ℤ), Icc (↑n) (↑n + 1)) = univ
Theorem: Monoid.exponent_eq_zero_iff
File: Mathlib/GroupTheory/Exponent.lean

tactic: simp only [exponentExists_iff_ne_zero, Classical.not_not]
state_before: G : Type u
inst✝ : Monoid G
⊢ exponent G = 0 ↔ ¬ExponentExists G
Theorem: Primrec.of_equiv_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_2
β✝ : Type ?u.27775
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_1
e : β ≃ α
f : σ → β
this : Primcodable β := Primcodable.ofEquiv α e
h : Primrec fun a => ↑e (f a)
a : σ
⊢ ↑e.symm (↑e (f a)) = f a
Theorem: OrderIso.image_Iio
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: rw [e.image_eq_preimage, e.symm.preimage_Iio, e.symm_symm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a : α
⊢ ↑e '' Iio a = Iio (↑e a)
Theorem: PowerSeries.eq_X_mul_shift_add_const
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext (_ | n)
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ φ = (X * mk fun p => ↑(coeff R (p + 1)) φ) + ↑(C R) (↑(constantCoeff R) φ)

tactic: simp only [Nat.zero_eq, coeff_zero_eq_constantCoeff, map_add, map_mul, constantCoeff_X,
  zero_mul, coeff_zero_C, zero_add]
state_before: case h.zero
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ ↑(coeff R Nat.zero) φ = ↑(coeff R Nat.zero) ((X * mk fun p => ↑(coeff R (p + 1)) φ) + ↑(C R) (↑(constantCoeff R) φ))

tactic: simp only [coeff_succ_X_mul, coeff_mk, LinearMap.map_add, coeff_C, n.succ_ne_zero, sub_zero,
  if_false, add_zero]
state_before: case h.succ
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
⊢ ↑(coeff R (Nat.succ n)) φ =
    ↑(coeff R (Nat.succ n)) ((X * mk fun p => ↑(coeff R (p + 1)) φ) + ↑(C R) (↑(constantCoeff R) φ))
Theorem: WithTop.preimage_coe_Ioc
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ioc ↑a ↑b = Ioc a b
Theorem: CategoryTheory.Limits.ImageMap.factor_map
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
m : ImageMap sq
⊢ (factorThruImage f.hom ≫ m.map) ≫ image.ι g.hom = (sq.left ≫ factorThruImage g.hom) ≫ image.ι g.hom
Theorem: List.Perm.bagInter_left
File: Mathlib/Data/List/Perm.lean

tactic: induction' l with a l IH generalizing t₁ t₂ p
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
l t₁ t₂ : List α
p : t₁ ~ t₂
⊢ List.bagInter l t₁ = List.bagInter l t₂

tactic: by_cases h : a ∈ t₁
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
t₁✝ t₂✝ : List α
p✝ : t₁✝ ~ t₂✝
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → List.bagInter l t₁ = List.bagInter l t₂
t₁ t₂ : List α
p : t₁ ~ t₂
⊢ List.bagInter (a :: l) t₁ = List.bagInter (a :: l) t₂

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
t₁✝ t₂✝ : List α
p✝ : t₁✝ ~ t₂✝
t₁ t₂ : List α
p : t₁ ~ t₂
⊢ List.bagInter [] t₁ = List.bagInter [] t₂

tactic: simp [h, p.subset h, IH (p.erase _)]
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
t₁✝ t₂✝ : List α
p✝ : t₁✝ ~ t₂✝
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → List.bagInter l t₁ = List.bagInter l t₂
t₁ t₂ : List α
p : t₁ ~ t₂
h : a ∈ t₁
⊢ List.bagInter (a :: l) t₁ = List.bagInter (a :: l) t₂

tactic: simp [h, mt p.mem_iff.2 h, IH p]
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
t₁✝ t₂✝ : List α
p✝ : t₁✝ ~ t₂✝
a : α
l : List α
IH : ∀ {t₁ t₂ : List α}, t₁ ~ t₂ → List.bagInter l t₁ = List.bagInter l t₂
t₁ t₂ : List α
p : t₁ ~ t₂
h : ¬a ∈ t₁
⊢ List.bagInter (a :: l) t₁ = List.bagInter (a :: l) t₂
Theorem: FirstOrder.Language.Theory.model_singleton_iff
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.522501
P : Type ?u.522504
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
φ : Sentence L
⊢ M ⊨ {φ} ↔ M ⊨ φ
Theorem: tendstoLocallyUniformlyOn_iff_forall_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [mem_map, mem_prod_iff_right]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
x✝³ : α
x✝² : x✝³ ∈ s
x✝¹ : Set (β × β)
x✝ : x✝¹ ∈ 𝓤 β
⊢ (∃ t, t ∈ 𝓝[s] x✝³ ∧ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (f y, F n y) ∈ x✝¹) ↔
    x✝¹ ∈ map (fun y => (f y.snd, F y.fst y.snd)) (p ×ˢ 𝓝[s] x✝³)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
x✝³ : α
x✝² : x✝³ ∈ s
x✝¹ : Set (β × β)
x✝ : x✝¹ ∈ 𝓤 β
⊢ (∃ t, t ∈ 𝓝[s] x✝³ ∧ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (f y, F n y) ∈ x✝¹) ↔
    ∃ t, t ∈ 𝓝[s] x✝³ ∧ ∀ᶠ (x : ι) in p, ∀ (y : α), y ∈ t → (x, y) ∈ (fun y => (f y.snd, F y.fst y.snd)) ⁻¹' x✝¹
Theorem: Dfinsupp.erase_same
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp
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✝ i : ι
f : Π₀ (i : ι), β i
⊢ ↑(erase i f) i = 0
Theorem: Multiset.nodup_iff_ne_cons_cons
File: Mathlib/Data/Multiset/Nodup.lean

tactic: rwa [cons_add, cons_add, zero_add] at s_eq
state_before: α : Type u_1
β : Type ?u.1277
γ : Type ?u.1280
r : α → α → Prop
s✝ t✝ : Multiset α
a✝ : α
s : Multiset α
h : ∀ (a : α) (t : Multiset α), s ≠ a ::ₘ a ::ₘ t
a : α
le : a ::ₘ a ::ₘ 0 ≤ s
t : Multiset α
s_eq : s = a ::ₘ a ::ₘ 0 + t
⊢ s = a ::ₘ a ::ₘ t
Theorem: FractionalIdeal.mul_left_le_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: convert mul_right_le_iff hJ using 1
state_before: R : Type ?u.702098
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ J * I ≤ J * I' ↔ I ≤ I'

tactic: simp only [mul_comm]
state_before: case h.e'_1.a
R : Type ?u.702098
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ J * I ≤ J * I' ↔ I * J ≤ I' * J
Theorem: WType.cardinal_mk_le_of_le
File: Mathlib/Data/W/Cardinal.lean

tactic: induction' κ using Cardinal.inductionOn with γ
state_before: α : Type u
β : α → Type u
κ : Cardinal
hκ : (sum fun a => κ ^ (#β a)) ≤ κ
⊢ (#WType β) ≤ κ

tactic: simp only [Cardinal.power_def, ← Cardinal.mk_sigma, Cardinal.le_def] at hκ
state_before: case h
α : Type u
β : α → Type u
κ : Cardinal
hκ✝ : (sum fun a => κ ^ (#β a)) ≤ κ
γ : Type u
hκ : (sum fun a => (#γ) ^ (#β a)) ≤ (#γ)
⊢ (#WType β) ≤ (#γ)

tactic: cases' hκ with hκ
state_before: case h
α : Type u
β : α → Type u
κ : Cardinal
hκ✝ : (sum fun a => κ ^ (#β a)) ≤ κ
γ : Type u
hκ : Nonempty ((i : α) × (β i → γ) ↪ γ)
⊢ (#WType β) ≤ (#γ)

tactic: exact Cardinal.mk_le_of_injective (elim_injective _ hκ.1 hκ.2)
state_before: case h.intro
α : Type u
β : α → Type u
κ : Cardinal
hκ✝ : (sum fun a => κ ^ (#β a)) ≤ κ
γ : Type u
hκ : (i : α) × (β i → γ) ↪ γ
⊢ (#WType β) ≤ (#γ)
Theorem: Mathlib.Tactic.Ring.add_congr
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a a' b b' c : R
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' + b' = c
⊢ a + b = c

tactic: rfl
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a' b' : R
⊢ a' + b' = a' + b'
Theorem: Complex.sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [ofReal_sin]
state_before: ⊢ sin (↑π / 2) = ↑(Real.sin (π / 2))

tactic: simp
state_before: ⊢ sin (↑π / 2) = sin ↑(π / 2)

tactic: simp
state_before: ⊢ ↑(Real.sin (π / 2)) = 1
Theorem: Con.lift_apply_mk'
File: Mathlib/GroupTheory/Congruence.lean

tactic: rw [c.eq.2 h]
state_before: M : Type ?u.60873
N : Type ?u.60876
P : Type ?u.60879
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y✝ : M
f✝ : M →* P
f : Con.Quotient c →* P
x y : M
h : ↑c x y
⊢ ↑f ↑x = ↑f ↑y

tactic: ext x
state_before: M : Type u_1
N : Type ?u.60876
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f✝ : M →* P
f : Con.Quotient c →* P
⊢ lift c (MonoidHom.comp f (mk' c)) (_ : ∀ (x y : M), ↑c x y → ↑f ↑x = ↑f ↑y) = f

tactic: rcases x with ⟨⟩
state_before: case h
M : Type u_1
N : Type ?u.60876
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y : M
f✝ : M →* P
f : Con.Quotient c →* P
x : Con.Quotient c
⊢ ↑(lift c (MonoidHom.comp f (mk' c)) (_ : ∀ (x y : M), ↑c x y → ↑f ↑x = ↑f ↑y)) x = ↑f x

tactic: rfl
state_before: case h.mk
M : Type u_1
N : Type ?u.60876
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y : M
f✝ : M →* P
f : Con.Quotient c →* P
x : Con.Quotient c
a✝ : M
⊢ ↑(lift c (MonoidHom.comp f (mk' c)) (_ : ∀ (x y : M), ↑c x y → ↑f ↑x = ↑f ↑y)) (Quot.mk r a✝) = ↑f (Quot.mk r a✝)
Theorem: Set.image2_iUnion₂_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image2_iUnion_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.249089
ι₂ : Sort ?u.249092
κ : ι → Sort u_5
κ₁ : ι → Sort ?u.249102
κ₂ : ι → Sort ?u.249107
κ' : ι' → Sort ?u.249112
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : (i : ι) → κ i → Set α
t : Set β
⊢ image2 f (⋃ (i : ι) (j : κ i), s i j) t = ⋃ (i : ι) (j : κ i), image2 f (s i j) t
Theorem: CategoryTheory.Limits.ι_colimitConstInitial_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: apply Limits.colimit.hom_ext
state_before: C✝ : Type u₁
inst✝³ : Category C✝
J : Type u_1
inst✝² : Category J
C : Type u_3
inst✝¹ : Category C
inst✝ : HasInitial C
j : J
⊢ colimit.ι ((Functor.const J).obj (⊥_ C)) j ≫ colimitConstInitial.hom = initial.to (⊥_ C)

tactic: aesop_cat
state_before: case w
C✝ : Type u₁
inst✝³ : Category C✝
J : Type u_1
inst✝² : Category J
C : Type u_3
inst✝¹ : Category C
inst✝ : HasInitial C
j : J
⊢ ∀ (j_1 : Discrete PEmpty),
    colimit.ι (Functor.empty C) j_1 ≫ colimit.ι ((Functor.const J).obj (⊥_ C)) j ≫ colimitConstInitial.hom =
      colimit.ι (Functor.empty C) j_1 ≫ initial.to (⊥_ C)
Theorem: InnerProductGeometry.norm_div_cos_angle_sub_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y = 0
⊢ ‖x‖ / Real.cos (angle x (x - y)) = ‖x - y‖

tactic: rw [← neg_eq_zero] at h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0 ∨ y = 0
⊢ ‖x‖ / Real.cos (angle x (x - y)) = ‖x - y‖

tactic: rw [sub_eq_add_neg, norm_div_cos_angle_add_of_inner_eq_zero h h0]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0 ∨ -y = 0
⊢ ‖x‖ / Real.cos (angle x (x - y)) = ‖x - y‖
Theorem: Finset.Ioc_eq_empty_iff
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
state_before: ι : Type ?u.1802
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioc a b = ∅ ↔ ¬a < b
Theorem: Nat.factorization_choose_le_log
File: Mathlib/Data/Nat/Choose/Factorization.lean

tactic: by_cases h : (choose n k).factorization p = 0
state_before: p n k : ℕ
⊢ ↑(factorization (choose n k)) p ≤ log p n

tactic: have hp : p.Prime := Not.imp_symm (choose n k).factorization_eq_zero_of_non_prime h
state_before: case neg
p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
⊢ ↑(factorization (choose n k)) p ≤ log p n

tactic: have hkn : k ≤ n := by
  refine' le_of_not_lt fun hnk => h _
  simp [choose_eq_zero_of_lt hnk]
state_before: case neg
p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
hp : Prime p
⊢ ↑(factorization (choose n k)) p ≤ log p n

tactic: rw [factorization_def _ hp, @padicValNat_def _ ⟨hp⟩ _ (choose_pos hkn)]
state_before: case neg
p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
hp : Prime p
hkn : k ≤ n
⊢ ↑(factorization (choose n k)) p ≤ log p n

tactic: simp only [hp.multiplicity_choose hkn (lt_add_one _), PartENat.get_natCast]
state_before: case neg
p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
hp : Prime p
hkn : k ≤ n
⊢ Part.get (multiplicity p (choose n k)) (_ : multiplicity.Finite p (choose n k)) ≤ log p n

tactic: refine (Finset.card_filter_le _ _).trans (le_of_eq (Nat.card_Ico _ _))
state_before: case neg
p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
hp : Prime p
hkn : k ≤ n
⊢ Finset.card (Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 (log p n + 1))) ≤ log p n

tactic: simp [h]
state_before: case pos
p n k : ℕ
h : ↑(factorization (choose n k)) p = 0
⊢ ↑(factorization (choose n k)) p ≤ log p n

tactic: refine' le_of_not_lt fun hnk => h _
state_before: p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
hp : Prime p
⊢ k ≤ n

tactic: simp [choose_eq_zero_of_lt hnk]
state_before: p n k : ℕ
h : ¬↑(factorization (choose n k)) p = 0
hp : Prime p
hnk : n < k
⊢ ↑(factorization (choose n k)) p = 0