tasksource/leandojo huggingface dataset:
Theorem: EuclideanGeometry.inner_weightedVSub
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [Finset.weightedVSub_apply, Finset.weightedVSub_apply,
  inner_sum_smul_sum_smul_of_sum_eq_zero _ h₁ _ h₂]
state_before: V : Type u_3
P : Type u_4
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
ι₁ : Type u_1
s₁ : Finset ι₁
w₁ : ι₁ → ℝ
p₁ : ι₁ → P
h₁ : ∑ i in s₁, w₁ i = 0
ι₂ : Type u_2
s₂ : Finset ι₂
w₂ : ι₂ → ℝ
p₂ : ι₂ → P
h₂ : ∑ i in s₂, w₂ i = 0
⊢ inner (↑(Finset.weightedVSub s₁ p₁) w₁) (↑(Finset.weightedVSub s₂ p₂) w₂) =
    (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2

tactic: simp_rw [vsub_sub_vsub_cancel_right]
state_before: V : Type u_3
P : Type u_4
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
ι₁ : Type u_1
s₁ : Finset ι₁
w₁ : ι₁ → ℝ
p₁ : ι₁ → P
h₁ : ∑ i in s₁, w₁ i = 0
ι₂ : Type u_2
s₂ : Finset ι₂
w₂ : ι₂ → ℝ
p₂ : ι₂ → P
h₂ : ∑ i in s₂, w₂ i = 0
⊢ (-∑ i₁ in s₁,
          ∑ i₂ in s₂,
            w₁ i₁ * w₂ i₂ *
              (‖p₁ i₁ -ᵥ choice (_ : Nonempty P) - (p₂ i₂ -ᵥ choice (_ : Nonempty P))‖ *
                ‖p₁ i₁ -ᵥ choice (_ : Nonempty P) - (p₂ i₂ -ᵥ choice (_ : Nonempty P))‖)) /
      2 =
    (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2

tactic: rcongr (i₁ i₂) <;> rw [dist_eq_norm_vsub V (p₁ i₁) (p₂ i₂)]
state_before: V : Type u_3
P : Type u_4
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
ι₁ : Type u_1
s₁ : Finset ι₁
w₁ : ι₁ → ℝ
p₁ : ι₁ → P
h₁ : ∑ i in s₁, w₁ i = 0
ι₂ : Type u_2
s₂ : Finset ι₂
w₂ : ι₂ → ℝ
p₂ : ι₂ → P
h₂ : ∑ i in s₂, w₂ i = 0
⊢ (-∑ x in s₁, ∑ x_1 in s₂, w₁ x * w₂ x_1 * (‖p₁ x -ᵥ p₂ x_1‖ * ‖p₁ x -ᵥ p₂ x_1‖)) / 2 =
    (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (dist (p₁ i₁) (p₂ i₂) * dist (p₁ i₁) (p₂ i₂))) / 2
Theorem: MvPolynomial.pderiv_X
File: Mathlib/Data/MvPolynomial/PDeriv.lean

tactic: rw [pderiv_def, mkDerivation_X]
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : DecidableEq σ
i j : σ
⊢ ↑(pderiv i) (X j) = Pi.single i 1 j
Theorem: LieSubmodule.comap_incl_eq_top
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.coeSubmodule_comap, LieSubmodule.incl_coe,
  LieSubmodule.top_coeSubmodule, Submodule.comap_subtype_eq_top, coeSubmodule_le_coeSubmodule]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
⊢ comap (incl N) N₂ = ⊤ ↔ N ≤ N₂
Theorem: IsLocalization.Away.mul_invSelf
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: convert IsLocalization.mk'_mul_mk'_eq_one (M := Submonoid.powers x) (S := S) _ 1
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.3731
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
⊢ ↑(algebraMap R S) x * invSelf x = 1

tactic: symm
state_before: case h.e'_2.h.e'_5
R : Type u_2
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.3731
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
⊢ ↑(algebraMap R S) x = mk' S (↑{ val := x, property := (_ : x ∈ Submonoid.powers x) }) 1

tactic: apply IsLocalization.mk'_one
state_before: case h.e'_2.h.e'_5
R : Type u_2
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.3731
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
⊢ mk' S (↑{ val := x, property := (_ : x ∈ Submonoid.powers x) }) 1 = ↑(algebraMap R S) x
Theorem: Cardinal.cast_toNat_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [toNat_apply_of_lt_aleph0 h, ← Classical.choose_spec (lt_aleph0.1 h)]
state_before: α β : Type u
c : Cardinal
h : c < ℵ₀
⊢ ↑(↑toNat c) = c
Theorem: TopologicalSpace.Opens.adjunction_counit_app_self
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: simp
state_before: X : TopCat
U : Opens ↑X
⊢ (map (inclusion U) ⋙ IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj U =
    (𝟭 (Opens ↑X)).obj U
Theorem: Nat.totient_prime_pow
File: Mathlib/Data/Nat/Totient.lean

tactic: rcases exists_eq_succ_of_ne_zero (pos_iff_ne_zero.1 hn) with ⟨m, rfl⟩
state_before: p : ℕ
hp : Prime p
n : ℕ
hn : 0 < n
⊢ φ (p ^ n) = p ^ (n - 1) * (p - 1)

tactic: exact totient_prime_pow_succ hp _
state_before: case intro
p : ℕ
hp : Prime p
m : ℕ
hn : 0 < succ m
⊢ φ (p ^ succ m) = p ^ (succ m - 1) * (p - 1)
Theorem: IsClosed.interior_union_right
File: Mathlib/Topology/Basic.lean

tactic: simpa only [union_comm _ t] using h.interior_union_left
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s t : Set α
h : IsClosed t
⊢ interior (s ∪ t) ⊆ interior s ∪ t
Theorem: EuclideanGeometry.angle_eq_left
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: unfold angle
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
⊢ ∠ p1 p1 p2 = π / 2

tactic: rw [vsub_self]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
⊢ InnerProductGeometry.angle (p1 -ᵥ p1) (p2 -ᵥ p1) = π / 2

tactic: exact angle_zero_left _
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
⊢ InnerProductGeometry.angle 0 (p2 -ᵥ p1) = π / 2
Theorem: MeasureTheory.SimpleFunc.coe_injective
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: cases f
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9713
δ : Type ?u.9716
inst✝ : MeasurableSpace α
f g : α →ₛ β
H : ↑f = ↑g
⊢ f = g

tactic: cases g
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type ?u.9713
δ : Type ?u.9716
inst✝ : MeasurableSpace α
g : α →ₛ β
toFun✝ : α → β
measurableSet_fiber'✝ : ∀ (x : β), MeasurableSet (toFun✝ ⁻¹' {x})
finite_range'✝ : Set.Finite (range toFun✝)
H : ↑{ toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = ↑g
⊢ { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = g

tactic: congr
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type ?u.9713
δ : Type ?u.9716
inst✝ : MeasurableSpace α
toFun✝¹ : α → β
measurableSet_fiber'✝¹ : ∀ (x : β), MeasurableSet (toFun✝¹ ⁻¹' {x})
finite_range'✝¹ : Set.Finite (range toFun✝¹)
toFun✝ : α → β
measurableSet_fiber'✝ : ∀ (x : β), MeasurableSet (toFun✝ ⁻¹' {x})
finite_range'✝ : Set.Finite (range toFun✝)
H :
  ↑{ toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =
    ↑{ toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ }
⊢ { toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =
    { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ }
Theorem: List.erase_cons_tail
File: Std/Data/List/Lemmas.lean

tactic: simp only [erase_cons, if_neg h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ≠ a
⊢ List.erase (b :: l) a = b :: List.erase l a
Theorem: Primrec.dom_denumerable
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α✝ : Type ?u.19256
β✝ : Type ?u.19259
σ : Type ?u.19262
inst✝⁴ : Primcodable α✝
inst✝³ : Primcodable β✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Primcodable β
f : α → β
h : Primrec f
n : ℕ
⊢ Nat.pred (encode (Option.map f (decode n))) = encode (f (ofNat α n))

tactic: simp
state_before: α✝ : Type ?u.19256
β✝ : Type ?u.19259
σ : Type ?u.19262
inst✝⁴ : Primcodable α✝
inst✝³ : Primcodable β✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Primcodable β
f : α → β
h : Nat.Primrec fun n => encode (f (ofNat α n))
n : ℕ
⊢ Nat.succ (encode (f (ofNat α n))) = encode (Option.map f (decode n))
Theorem: Real.rpow_lt_rpow_of_exponent_lt
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: repeat' rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
state_before: x y z : ℝ
hx : 1 < x
hyz : y < z
⊢ x ^ y < x ^ z

tactic: rw [exp_lt_exp]
state_before: x y z : ℝ
hx : 1 < x
hyz : y < z
⊢ exp (log x * y) < exp (log x * z)

tactic: exact mul_lt_mul_of_pos_left hyz (log_pos hx)
state_before: x y z : ℝ
hx : 1 < x
hyz : y < z
⊢ log x * y < log x * z

tactic: rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
state_before: x y z : ℝ
hx : 1 < x
hyz : y < z
⊢ exp (log x * y) < exp (log x * z)
Theorem: Filter.eventuallyEq_univ
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [eventuallyEq_set]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.183630
ι : Sort x
s : Set α
l : Filter α
⊢ s =ᶠ[l] univ ↔ s ∈ l
Theorem: SignType.pos_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ 0 < a ↔ a = 1
Theorem: linearIndependent_subtype
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: apply @linearIndependent_comp_subtype _ _ _ id
state_before: ι : Type u'
ι' : Type ?u.197690
R : Type u_2
K : Type ?u.197696
M : Type u_1
M' : Type ?u.197702
M'' : Type ?u.197705
V : Type u
V' : Type ?u.197710
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
⊢ (LinearIndependent R fun x => ↑x) ↔
    ∀ (l : M →₀ R), l ∈ Finsupp.supported R R s → ↑(Finsupp.total M M R id) l = 0 → l = 0
Theorem: ContinuousLinearEquiv.trans_toLinearEquiv
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_5
inst✝²⁴ : Semiring R₁
inst✝²³ : Semiring R₂
inst✝²² : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂
inst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁
inst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃
inst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_3
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.1545569
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_4
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type u_6
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.1545596
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
e₁ : M₁ ≃SL[σ₁₂] M₂
e₂ : M₂ ≃SL[σ₂₃] M₃
⊢ (ContinuousLinearEquiv.trans e₁ e₂).toLinearEquiv = LinearEquiv.trans e₁.toLinearEquiv e₂.toLinearEquiv

tactic: rfl
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_5
inst✝²⁴ : Semiring R₁
inst✝²³ : Semiring R₂
inst✝²² : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂
inst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁
inst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃
inst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_3
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.1545569
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_4
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type u_6
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.1545596
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
e₁ : M₁ ≃SL[σ₁₂] M₂
e₂ : M₂ ≃SL[σ₂₃] M₃
x✝ : M₁
⊢ ↑(ContinuousLinearEquiv.trans e₁ e₂).toLinearEquiv x✝ = ↑(LinearEquiv.trans e₁.toLinearEquiv e₂.toLinearEquiv) x✝
Theorem: Int.odd_add
File: Mathlib/Data/Int/Parity.lean

tactic: rw [odd_iff_not_even, even_add, not_iff, odd_iff_not_even]
state_before: m n : ℤ
⊢ Odd (m + n) ↔ (Odd m ↔ Even n)
Theorem: Finset.range_image_pred_top_sub
File: Mathlib/Data/Nat/Interval.lean

tactic: cases n
state_before: a b c n : ℕ
⊢ image (fun j => n - 1 - j) (range n) = range n

tactic: rw [range_zero, image_empty]
state_before: case zero
a b c : ℕ
⊢ image (fun j => zero - 1 - j) (range zero) = range zero

tactic: rw [Finset.range_eq_Ico, Nat.Ico_image_const_sub_eq_Ico (Nat.zero_le _)]
state_before: case succ
a b c n✝ : ℕ
⊢ image (fun j => succ n✝ - 1 - j) (range (succ n✝)) = range (succ n✝)

tactic: simp_rw [succ_sub_succ, tsub_zero, tsub_self]
state_before: case succ
a b c n✝ : ℕ
⊢ Ico (succ n✝ - 1 + 1 - succ n✝) (succ n✝ - 1 + 1 - 0) = Ico 0 (succ n✝)
Theorem: BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: simp [RCond, hl]
state_before: ι✝ : Type ?u.29939
inst✝ : Fintype ι✝
I J : Box ι✝
c c₁ c₂ : ℝ≥0
r✝ r₁ r₂ : (ι✝ → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I
l✝ l₁ l₂ : IntegrationParams
ι : Type u_1
l : IntegrationParams
hl : l.bRiemann = false
r : (ι → ℝ) → ↑(Set.Ioi 0)
⊢ RCond l r
Theorem: Bool.or_and_distrib_left
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> simp
state_before: a b c : Bool
⊢ (a || b && c) = ((a || b) && (a || c))
Theorem: MeasureTheory.exists_measurable_superset₂
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simpa only [Bool.forall_bool.trans and_comm] using
  exists_measurable_superset_forall_eq (fun b => cond b μ ν) s
state_before: α : Type u_1
β : Type ?u.15260
γ : Type ?u.15263
δ : Type ?u.15266
ι : Type ?u.15269
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ ν : Measure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = ↑↑μ s ∧ ↑↑ν t = ↑↑ν s
Theorem: ball_eq_of_symmetry
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext y
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.55168
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x : β
⊢ ball x V = {y | (y, x) ∈ V}

tactic: rw [mem_ball_symmetry hV]
state_before: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.55168
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ y ∈ ball x V ↔ y ∈ {y | (y, x) ∈ V}

tactic: exact Iff.rfl
state_before: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.55168
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ x ∈ ball y V ↔ y ∈ {y | (y, x) ∈ V}
Theorem: PathConnectedSpace.exists_path_through_family'
File: Mathlib/Topology/PathConnected.lean

tactic: have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)
state_before: X : Type u_1
Y : Type ?u.698693
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.698708
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: rcases this.exists_path_through_family' p fun _i => True.intro with ⟨γ, t, -, h⟩
state_before: X : Type u_1
Y : Type ?u.698693
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.698708
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: exact ⟨γ, t, h⟩
state_before: case intro.intro.intro
X : Type u_1
Y : Type ?u.698693
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.698708
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
γ : Path (p 0) (p ↑n)
t : Fin (n + 1) → ↑I
h : ∀ (i : Fin (n + 1)), ↑γ (t i) = p i
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: infer_instance
state_before: X : Type u_1
Y : Type ?u.698693
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.698708
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ PathConnectedSpace X
Theorem: PNat.dvd_prime
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [PNat.dvd_iff]
state_before: p m : ℕ+
pp : Prime p
⊢ m ∣ p ↔ m = 1 ∨ m = p

tactic: rw [Nat.dvd_prime pp]
state_before: p m : ℕ+
pp : Prime p
⊢ ↑m ∣ ↑p ↔ m = 1 ∨ m = p

tactic: simp
state_before: p m : ℕ+
pp : Prime p
⊢ ↑m = 1 ∨ ↑m = ↑p ↔ m = 1 ∨ m = p
Theorem: List.next_ne_head_ne_getLast
File: Mathlib/Data/List/Cycle.lean

tactic: simpa [hy] using h
state_before: α : Type ?u.59864
inst✝ : DecidableEq α
l : List α
x : α
h✝ : x ∈ l
y : α
h : x ∈ y :: l
hy : x ≠ y
hx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])
⊢ x ∈ l

tactic: rw [next, next, nextOr_cons_of_ne _ _ _ _ hy, nextOr_eq_nextOr_of_mem_of_ne]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h✝ : x ∈ l
y : α
h : x ∈ y :: l
hy : x ≠ y
hx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])
⊢ next (y :: l) x h = next l x (_ : x ∈ l)

tactic: rwa [getLast_cons] at hx
state_before: case x_mem
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h✝ : x ∈ l
y : α
h : x ∈ y :: l
hy : x ≠ y
hx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])
⊢ x ∈ l

tactic: exact ne_nil_of_mem (by assumption)
state_before: case x_mem
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h✝ : x ∈ l
y : α
h : x ∈ y :: l
hy : x ≠ y
hx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])
⊢ l ≠ []

tactic: assumption
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h✝ : x ∈ l
y : α
h : x ∈ y :: l
hy : x ≠ y
hx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])
⊢ ?m.65092 ∈ l

tactic: rwa [getLast_cons] at hx
state_before: case x_ne
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h✝ : x ∈ l
y : α
h : x ∈ y :: l
hy : x ≠ y
hx : x ≠ getLast (y :: l) (_ : y :: l ≠ [])
⊢ x ≠ getLast l (_ : l ≠ [])
Theorem: Bitraversable.tfst_tsnd
File: Mathlib/Control/Bitraversable/Lemmas.lean

tactic: rw [← comp_bitraverse]
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : IsLawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ β₀ β₁ : Type u
f : α₀ → F α₁
f' : β₀ → G β₁
x : t α₀ β₀
⊢ Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x

tactic: simp only [Function.comp, map_pure]
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : IsLawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ β₀ β₁ : Type u
f : α₀ → F α₁
f' : β₀ → G β₁
x : t α₀ β₀
⊢ bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk ∘ map pure ∘ f') x =
    bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x
Theorem: Finset.univ_pow
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [coe_pow, coe_univ, Set.univ_pow hn]
state_before: F : Type ?u.474133
α : Type u_1
β : Type ?u.474139
γ : Type ?u.474142
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : Monoid α
s t : Finset α
a : α
m n : ℕ
inst✝ : Fintype α
hn : n ≠ 0
⊢ ↑(univ ^ n) = ↑univ
Theorem: Matrix.conjTranspose_sub
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.967201
m : Type u_1
n : Type u_2
o : Type ?u.967210
m' : o → Type ?u.967215
n' : o → Type ?u.967220
R : Type ?u.967223
S : Type ?u.967226
α : Type v
β : Type w
γ : Type ?u.967233
inst✝¹ : AddGroup α
inst✝ : StarAddMonoid α
M N : Matrix m n α
⊢ ∀ (i : n) (j : m), (M - N)ᴴ i j = (Mᴴ - Nᴴ) i j
Theorem: Complex.sinh_add_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [add_comm, cosh_add_sinh]
state_before: x y : ℂ
⊢ sinh x + cosh x = exp x
Theorem: Finsupp.coe_neLocus
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: ext
state_before: α : Type u_1
M : Type ?u.2198
N : Type u_2
P : Type ?u.2204
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
⊢ ↑(neLocus f g) = {x | ↑f x ≠ ↑g x}

tactic: exact mem_neLocus
state_before: case h
α : Type u_1
M : Type ?u.2198
N : Type u_2
P : Type ?u.2204
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
x✝ : α
⊢ x✝ ∈ ↑(neLocus f g) ↔ x✝ ∈ {x | ↑f x ≠ ↑g x}
Theorem: IsUnit.dvd_mul_right
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: rcases hu with ⟨u, rfl⟩
state_before: α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ a ∣ b * u ↔ a ∣ b

tactic: apply Units.dvd_mul_right
state_before: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a ∣ b * ↑u ↔ a ∣ b
Theorem: Real.arccos_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos]
state_before: x : ℝ
⊢ 0 < arccos x ↔ x < 1
Theorem: Rat.mkRat_eq_zero
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mkRat_def, d0]
state_before: d : Nat
n : Int
d0 : d ≠ 0
⊢ mkRat n d = 0 ↔ n = 0
Theorem: Function.Embedding.setValue_eq
File: Mathlib/Logic/Embedding/Basic.lean

tactic: simp [setValue]
state_before: α : Sort u_1
β : Sort u_2
f : α ↪ β
a : α
b : β
inst✝¹ : (a' : α) → Decidable (a' = a)
inst✝ : (a' : α) → Decidable (↑f a' = b)
⊢ ↑(setValue f a b) a = b
Theorem: TopCat.fst_embedding_of_right_embedding
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: convert (homeoOfIso (asIso (pullback.fst : pullback f (𝟙 S) ⟶ _))).embedding.comp
    (pullback_map_embedding_of_embeddings (i₁ := 𝟙 X)
      f g f (𝟙 _) (homeoOfIso (Iso.refl _)).embedding H (𝟙 _) rfl (by simp))
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : Embedding ((forget TopCat).map g)
⊢ Embedding ((forget TopCat).map pullback.fst)

tactic: erw [← coe_comp]
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : Embedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj X = ↑X
⊢ (forget TopCat).map pullback.fst =
    ↑(homeoOfIso (asIso pullback.fst)) ∘
      (forget TopCat).map (pullback.map f g f (𝟙 S) (𝟙 X) g (𝟙 S) (_ : f ≫ 𝟙 S = f ≫ 𝟙 S) (_ : g ≫ 𝟙 S = g ≫ 𝟙 S))

tactic: simp
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : Embedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj X = ↑X
⊢ (forget TopCat).map pullback.fst =
    (forget TopCat).map
      (pullback.map f g f (𝟙 S) (𝟙 X) g (𝟙 S) (_ : f ≫ 𝟙 S = f ≫ 𝟙 S) (_ : g ≫ 𝟙 S = g ≫ 𝟙 S) ≫
        (asIso pullback.fst).hom)

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : Embedding ((forget TopCat).map g)
⊢ g ≫ 𝟙 S = g ≫ 𝟙 S
Theorem: RatFunc.smul_eq_C_smul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: cases' x with x
state_before: K : Type u
inst✝ : CommRing K
R : Type ?u.178730
x : RatFunc K
r : K
⊢ r • x = ↑Polynomial.C r • x

tactic: induction x using Localization.induction_on
state_before: case ofFractionRing
K : Type u
inst✝ : CommRing K
R : Type ?u.178730
r : K
x : FractionRing K[X]
⊢ r • { toFractionRing := x } = ↑Polynomial.C r • { toFractionRing := x }

tactic: rw [← ofFractionRing_smul, ← ofFractionRing_smul, Localization.smul_mk,
  Localization.smul_mk, smul_eq_mul, Polynomial.smul_eq_C_mul]
state_before: case ofFractionRing.H
K : Type u
inst✝ : CommRing K
R : Type ?u.178730
r : K
y✝ : K[X] × { x // x ∈ K[X]⁰ }
⊢ r • { toFractionRing := Localization.mk y✝.fst y✝.snd } =
    ↑Polynomial.C r • { toFractionRing := Localization.mk y✝.fst y✝.snd }