tasksource/leandojo huggingface dataset:
Theorem: PFunctor.liftp_iff'
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: simp only [liftp_iff, Sigma.mk.inj_iff]
state_before: P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
⊢ Liftp p { fst := a, snd := f } ↔ ∀ (i : B P a), p (f i)

tactic: constructor <;> intro h
state_before: P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
⊢ (∃ a_1 f_1, { fst := a, snd := f } = { fst := a_1, snd := f_1 } ∧ ∀ (i : B P a_1), p (f_1 i)) ↔ ∀ (i : B P a), p (f i)

tactic: repeat' first |constructor|assumption
state_before: case mpr
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
h : ∀ (i : B P a), p (f i)
⊢ ∃ a_1 f_1, { fst := a, snd := f } = { fst := a_1, snd := f_1 } ∧ ∀ (i : B P a_1), p (f_1 i)

tactic: rcases h with ⟨a', f', heq, h'⟩
state_before: case mp
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
h : ∃ a_1 f_1, { fst := a, snd := f } = { fst := a_1, snd := f_1 } ∧ ∀ (i : B P a_1), p (f_1 i)
⊢ ∀ (i : B P a), p (f i)

tactic: cases heq
state_before: case mp.intro.intro.intro
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
a' : P.A
f' : B P a' → α
heq : { fst := a, snd := f } = { fst := a', snd := f' }
h' : ∀ (i : B P a'), p (f' i)
⊢ ∀ (i : B P a), p (f i)

tactic: assumption
state_before: case mp.intro.intro.intro.refl
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
h' : ∀ (i : B P a), p (f i)
⊢ ∀ (i : B P a), p (f i)

tactic: first |constructor|assumption
state_before: case mpr.h.h.right
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
h : ∀ (i : B P a), p (f i)
⊢ ∀ (i : B P a), p (f i)

tactic: constructor
state_before: case mpr.h.h.right
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
h : ∀ (i : B P a), p (f i)
⊢ ∀ (i : B P a), p (f i)

tactic: assumption
state_before: case mpr.h.h.right
P : PFunctor
α : Type u
p : α → Prop
a : P.A
f : B P a → α
h : ∀ (i : B P a), p (f i)
⊢ ∀ (i : B P a), p (f i)
Theorem: UniformContinuous.inv
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: have : UniformContinuous fun x => 1 / f x := uniformContinuous_const.div hf
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
⊢ UniformContinuous fun x => (f x)⁻¹

tactic: simp_all
state_before: α : Type u_2
β : Type u_1
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
this : UniformContinuous fun x => 1 / f x
⊢ UniformContinuous fun x => (f x)⁻¹
Theorem: HasFDerivWithinAt.hasFDerivAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rwa [← univ_inter s, hasFDerivWithinAt_inter hs, hasFDerivWithinAt_univ] at h
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.246750
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.246845
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivWithinAt f f' s x
hs : s ∈ 𝓝 x
⊢ HasFDerivAt f f' x
Theorem: Ideal.comap_map_of_surjective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [map_sub, hfsr, sub_self]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ↑f
I : Ideal R
r : R
h : ↑f r ∈ map f I
s : R
hsi : s ∈ ↑I
hfsr : ↑f s = ↑f r
⊢ ↑f (r - s) = 0
Theorem: AddMonoidAlgebra.single_pow
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp only [pow_zero, zero_nsmul]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1939465
inst✝¹ : Semiring k
inst✝ : AddMonoid G
a : G
b : k
⊢ single a b ^ 0 = single (0 • a) (b ^ 0)

tactic: rfl
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1939465
inst✝¹ : Semiring k
inst✝ : AddMonoid G
a : G
b : k
⊢ 1 = single 0 1

tactic: rw [pow_succ, pow_succ, single_pow n, single_mul_single, add_comm, add_nsmul, one_nsmul]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1939465
inst✝¹ : Semiring k
inst✝ : AddMonoid G
a : G
b : k
n : ℕ
⊢ single a b ^ (n + 1) = single ((n + 1) • a) (b ^ (n + 1))
Theorem: Real.exp_bound_div_one_sub_of_interval
File: Mathlib/Data/Complex/Exponential.lean

tactic: rcases eq_or_lt_of_le h1 with (rfl | h1)
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x < 1
⊢ exp x ≤ 1 / (1 - x)

tactic: simp
state_before: case inl
h1 : 0 ≤ 0
h2 : 0 < 1
⊢ exp 0 ≤ 1 / (1 - 0)

tactic: exact (exp_bound_div_one_sub_of_interval' h1 h2).le
state_before: case inr
x : ℝ
h1✝ : 0 ≤ x
h2 : x < 1
h1 : 0 < x
⊢ exp x ≤ 1 / (1 - x)
Theorem: PowerSeries.order_finite_iff_ne_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp only [order]
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ (order φ).Dom ↔ φ ≠ 0

tactic: constructor
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ (if h : φ = 0 then ⊤ else ↑(Nat.find (_ : ∃ n, ↑(coeff R n) φ ≠ 0))).Dom ↔ φ ≠ 0

tactic: split_ifs with h <;> intro H
state_before: case mp
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ (if h : φ = 0 then ⊤ else ↑(Nat.find (_ : ∃ n, ↑(coeff R n) φ ≠ 0))).Dom → φ ≠ 0

tactic: contrapose! H
state_before: case mp.inl
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
h : φ = 0
H : ⊤.Dom
⊢ φ ≠ 0

tactic: simp only [← Part.eq_none_iff']
state_before: case mp.inl
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
h H : φ = 0
⊢ ¬⊤.Dom

tactic: rfl
state_before: case mp.inl
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
h H : φ = 0
⊢ ⊤ = Part.none

tactic: exact h
state_before: case mp.inr
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
h : ¬φ = 0
H : (↑(Nat.find (_ : ∃ n, ↑(coeff R n) φ ≠ 0))).Dom
⊢ φ ≠ 0

tactic: intro h
state_before: case mpr
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ φ ≠ 0 → (if h : φ = 0 then ⊤ else ↑(Nat.find (_ : ∃ n, ↑(coeff R n) φ ≠ 0))).Dom

tactic: simp [h]
state_before: case mpr
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
h : φ ≠ 0
⊢ (if h : φ = 0 then ⊤ else ↑(Nat.find (_ : ∃ n, ↑(coeff R n) φ ≠ 0))).Dom
Theorem: MvPowerSeries.coeff_C_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simpa using coeff_add_monomial_mul 0 n φ a
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
n : σ →₀ ℕ
φ : MvPowerSeries σ R
a : R
⊢ ↑(coeff R n) (↑(C σ R) a * φ) = a * ↑(coeff R n) φ
Theorem: monotone_stabilizes_iff_artinian
File: Mathlib/RingTheory/Artinian.lean

tactic: rw [isArtinian_iff_wellFounded]
state_before: R : Type u_2
M : Type u_1
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ (∀ (f : ℕ →o (Submodule R M)ᵒᵈ), ∃ n, ∀ (m : ℕ), n ≤ m → ↑f n = ↑f m) ↔ IsArtinian R M

tactic: exact WellFounded.monotone_chain_condition.symm
state_before: R : Type u_2
M : Type u_1
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ (∀ (f : ℕ →o (Submodule R M)ᵒᵈ), ∃ n, ∀ (m : ℕ), n ≤ m → ↑f n = ↑f m) ↔ WellFounded fun x x_1 => x < x_1
Theorem: Polynomial.eq_X_add_C_of_degree_le_one
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : degree p ≤ 1
n : ℕ
⊢ coeff p Nat.zero = coeff (↑C (coeff p 1) * X + ↑C (coeff p 0)) Nat.zero

tactic: simp [coeff_C]
state_before: R : Type u
S : Type v
a b c d : R
n✝¹ m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : degree p ≤ 1
n✝ n : ℕ
⊢ coeff p (Nat.succ Nat.zero) = coeff (↑C (coeff p 1) * X + ↑C (coeff p 0)) (Nat.succ Nat.zero)

tactic: have : degree p < m.succ.succ := lt_of_le_of_lt h
  (Iff.mpr WithBot.coe_lt_coe <| Nat.succ_lt_succ <| Nat.zero_lt_succ m)
state_before: R : Type u
S : Type v
a b c d : R
n✝¹ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
h : degree p ≤ 1
n✝ n m : ℕ
⊢ coeff p (Nat.succ (Nat.succ m)) = coeff (↑C (coeff p 1) * X + ↑C (coeff p 0)) (Nat.succ (Nat.succ m))

tactic: simp [coeff_eq_zero_of_degree_lt this, coeff_C, Nat.succ_ne_zero, coeff_X, Nat.succ_inj',
  @eq_comm ℕ 0]
state_before: R : Type u
S : Type v
a b c d : R
n✝¹ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
h : degree p ≤ 1
n✝ n m : ℕ
this : degree p < ↑(Nat.succ (Nat.succ m))
⊢ coeff p (Nat.succ (Nat.succ m)) = coeff (↑C (coeff p 1) * X + ↑C (coeff p 0)) (Nat.succ (Nat.succ m))
Theorem: Equiv.Perm.toList_formPerm_isRotated_self
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: obtain ⟨k, hk, rfl⟩ := get_of_mem hx
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
x : α
hx : x ∈ l
⊢ toList (formPerm l) x ~r l

tactic: have hr : l ~r l.rotate k := ⟨k, rfl⟩
state_before: case intro.refl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
⊢ toList (formPerm l) (List.get l k) ~r l

tactic: rw [formPerm_eq_of_isRotated hn hr]
state_before: case intro.refl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ toList (formPerm l) (List.get l k) ~r l

tactic: rw [get_eq_get_rotate l k k]
state_before: case intro.refl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ toList (formPerm (rotate l ↑k)) (List.get l k) ~r l

tactic: simp only [Nat.mod_eq_of_lt k.2, tsub_add_cancel_of_le (le_of_lt k.2), Nat.mod_self]
state_before: case intro.refl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ toList (formPerm (rotate l ↑k))
      (List.get (rotate l ↑k)
        { val := (length l - ↑k % length l + ↑k) % length l,
          isLt := (_ : (length l - ↑k % length l + ↑k) % length l < length (rotate l ↑k)) }) ~r
    l

tactic: erw [toList_formPerm_nontrivial]
state_before: case intro.refl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ toList (formPerm (rotate l ↑k)) (List.get (rotate l ↑k) { val := 0, isLt := (_ : 0 < length (rotate l ↑k)) }) ~r l

tactic: simp
state_before: case intro.refl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ rotate l ↑k ~r l

tactic: simpa using hl
state_before: case intro.refl.hl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ 2 ≤ length (rotate l ↑k)

tactic: simpa using hn
state_before: case intro.refl.hn
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
l : List α
hl : 2 ≤ length l
hn : Nodup l
k : Fin (length l)
hx : List.get l k ∈ l
hr : l ~r rotate l ↑k
⊢ Nodup (rotate l ↑k)
Theorem: intervalIntegral.smul_integral_comp_mul_left
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_mul_left]
state_before: ι : Type ?u.14836785
𝕜 : Type ?u.14836788
E : Type u_1
F : Type ?u.14836794
A : Type ?u.14836797
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d : ℝ
f : ℝ → E
c : ℝ
⊢ (c • ∫ (x : ℝ) in a..b, f (c * x)) = ∫ (x : ℝ) in c * a..c * b, f x
Theorem: List.length_rotate'
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
x✝ : ℕ
⊢ length (rotate' [] x✝) = length []

tactic: rw [List.rotate', length_rotate' (l ++ [a]) n]
state_before: α : Type u
a : α
l : List α
n : ℕ
⊢ length (rotate' (a :: l) (n + 1)) = length (a :: l)

tactic: simp
state_before: α : Type u
a : α
l : List α
n : ℕ
⊢ length (l ++ [a]) = length (a :: l)
Theorem: Multiset.disjoint_toFinset
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [Finset.disjoint_iff_ne]
state_before: α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
⊢ _root_.Disjoint (toFinset m1) (toFinset m2) ↔ Disjoint m1 m2

tactic: refine' ⟨fun h a ha1 ha2 => _, _⟩
state_before: α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
⊢ (∀ (a : α), a ∈ toFinset m1 → ∀ (b : α), b ∈ toFinset m2 → a ≠ b) ↔ Disjoint m1 m2

tactic: rw [← Multiset.mem_toFinset] at ha1 ha2
state_before: case refine'_1
α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
h : ∀ (a : α), a ∈ toFinset m1 → ∀ (b : α), b ∈ toFinset m2 → a ≠ b
a : α
ha1 : a ∈ m1
ha2 : a ∈ m2
⊢ False

tactic: exact h _ ha1 _ ha2 rfl
state_before: case refine'_1
α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
h : ∀ (a : α), a ∈ toFinset m1 → ∀ (b : α), b ∈ toFinset m2 → a ≠ b
a : α
ha1✝ : a ∈ m1
ha1 : a ∈ toFinset m1
ha2✝ : a ∈ m2
ha2 : a ∈ toFinset m2
⊢ False

tactic: rintro h a ha b hb rfl
state_before: case refine'_2
α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
⊢ Disjoint m1 m2 → ∀ (a : α), a ∈ toFinset m1 → ∀ (b : α), b ∈ toFinset m2 → a ≠ b

tactic: rw [Multiset.mem_toFinset] at ha hb
state_before: case refine'_2
α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
h : Disjoint m1 m2
a : α
ha : a ∈ toFinset m1
hb : a ∈ toFinset m2
⊢ False

tactic: exact h ha hb
state_before: case refine'_2
α : Type u_1
β : Type ?u.559305
γ : Type ?u.559308
inst✝ : DecidableEq α
m1 m2 : Multiset α
h : Disjoint m1 m2
a : α
ha : a ∈ m1
hb : a ∈ m2
⊢ False
Theorem: IsUnit.mul_left_dvd
File: Mathlib/Algebra/Divisibility/Units.lean

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

tactic: apply Units.mul_left_dvd
state_before: case intro
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ ↑u * a ∣ b ↔ a ∣ b
Theorem: Complex.eqOn_of_isPreconnected_of_isMaxOn_norm
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: simp only [H₂, SameRay.rfl.norm_add, H₁, Function.const]
state_before: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : StrictConvexSpace ℝ F
f : E → F
U : Set E
c : E
hc : IsPreconnected U
ho : IsOpen U
hd : DifferentiableOn ℂ f U
hcU : c ∈ U
hm : IsMaxOn (norm ∘ f) U c
x : E
hx : x ∈ U
H₁ : ‖f x‖ = ‖f c‖
H₂ : ‖f x + f c‖ = ‖f c + f c‖
⊢ ‖f x + Function.const E (f c) x‖ = ‖f x‖ + ‖Function.const E (f c) x‖
Theorem: Computation.equiv_of_mem
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [mem_unique ma h1]
state_before: α : Type u
β : Type v
γ : Type w
s t : Computation α
a : α
h1 : a ∈ s
h2 : a ∈ t
a' : α
ma : a' ∈ s
⊢ a' ∈ t

tactic: exact h2
state_before: α : Type u
β : Type v
γ : Type w
s t : Computation α
a : α
h1 : a ∈ s
h2 : a ∈ t
a' : α
ma : a' ∈ s
⊢ a ∈ t

tactic: rw [mem_unique ma h2]
state_before: α : Type u
β : Type v
γ : Type w
s t : Computation α
a : α
h1 : a ∈ s
h2 : a ∈ t
a' : α
ma : a' ∈ t
⊢ a' ∈ s

tactic: exact h1
state_before: α : Type u
β : Type v
γ : Type w
s t : Computation α
a : α
h1 : a ∈ s
h2 : a ∈ t
a' : α
ma : a' ∈ t
⊢ a ∈ s
Theorem: NNReal.rpow_left_surjective
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp_rw [← rpow_mul, _root_.inv_mul_cancel hx, rpow_one]
state_before: x : ℝ
hx : x ≠ 0
y : ℝ≥0
⊢ (fun y => y ^ x) (y ^ x⁻¹) = y
Theorem: WithZeroTopology.hasBasis_nhds_of_ne_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [nhds_of_ne_zero h]
state_before: α : Type ?u.51011
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
x : Γ₀
h : x ≠ 0
⊢ HasBasis (𝓝 x) (fun x => True) fun x_1 => {x}

tactic: exact hasBasis_pure _
state_before: α : Type ?u.51011
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
x : Γ₀
h : x ≠ 0
⊢ HasBasis (pure x) (fun x => True) fun x_1 => {x}
Theorem: Metric.forall_of_forall_mem_closedBall
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: obtain ⟨R, hR, h⟩ : ∃ R ≥ dist y x, ∀ z : α, z ∈ closedBall x R → p z :=
  frequently_iff.1 H (Ici_mem_atTop (dist y x))
state_before: α : Type u
β : Type v
X : Type ?u.45555
ι : Type ?u.45558
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ (y : α), y ∈ closedBall x R → p y
y : α
⊢ p y

tactic: exact h _ hR
state_before: case intro.intro
α : Type u
β : Type v
X : Type ?u.45555
ι : Type ?u.45558
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
p : α → Prop
x : α
H : ∃ᶠ (R : ℝ) in atTop, ∀ (y : α), y ∈ closedBall x R → p y
y : α
R : ℝ
hR : R ≥ dist y x
h : ∀ (z : α), z ∈ closedBall x R → p z
⊢ p y
Theorem: Ctop.Realizer.ext'
File: Mathlib/Data/Analysis/Topology.lean

tactic: refine' eq_of_nhds_eq_nhds fun x ↦ _
state_before: α : Type u_1
β : Type ?u.19949
σ✝ : Type ?u.19952
τ : Type ?u.19955
T : TopologicalSpace α
σ : Type u_2
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ f F b ∧ f F b ⊆ s
⊢ toTopsp F = T

tactic: ext s
state_before: α : Type u_1
β : Type ?u.19949
σ✝ : Type ?u.19952
τ : Type ?u.19955
T : TopologicalSpace α
σ : Type u_2
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ f F b ∧ f F b ⊆ s
x : α
⊢ 𝓝 x = 𝓝 x

tactic: rw [mem_nhds_toTopsp, H]
state_before: case a
α : Type u_1
β : Type ?u.19949
σ✝ : Type ?u.19952
τ : Type ?u.19955
T : TopologicalSpace α
σ : Type u_2
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ f F b ∧ f F b ⊆ s
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ s ∈ 𝓝 x
Theorem: InnerProductGeometry.angle_smul_left_of_neg
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [angle_comm, angle_smul_right_of_neg y x hr, angle_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
r : ℝ
hr : r < 0
⊢ angle (r • x) y = angle (-x) y
Theorem: Pmf.support_uniformOfFintype
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp [mem_support_iff]
state_before: α✝ : Type ?u.17927
β : Type ?u.17930
γ : Type ?u.17933
inst✝³ : Fintype α✝
inst✝² : Nonempty α✝
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
x : α
⊢ x ∈ support (uniformOfFintype α) ↔ x ∈ ⊤
Theorem: Complex.integral_boundary_rect_of_differentiableOn_real
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: simpa only [← mem_interior_iff_mem_nhds, interior_reProdIm, uIcc, interior_Icc] using hx.1
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
z w : ℂ
Hd : DifferentiableOn ℝ f ([[z.re, w.re]] ×ℂ [[z.im, w.im]])
Hi : IntegrableOn (fun z => I • ↑(fderiv ℝ f z) 1 - ↑(fderiv ℝ f z) I) ([[z.re, w.re]] ×ℂ [[z.im, w.im]])
x : ℂ
hx : x ∈ Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im) \ ∅
⊢ [[z.re, w.re]] ×ℂ [[z.im, w.im]] ∈ 𝓝 x
Theorem: Submodule.map_one
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: ext
state_before: ι : Sort uι
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
A' : Type u_1
inst✝¹ : Semiring A'
inst✝ : Algebra R A'
f : A →ₐ[R] A'
⊢ map (AlgHom.toLinearMap f) 1 = 1

tactic: simp
state_before: case h
ι : Sort uι
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
A' : Type u_1
inst✝¹ : Semiring A'
inst✝ : Algebra R A'
f : A →ₐ[R] A'
x✝ : A'
⊢ x✝ ∈ map (AlgHom.toLinearMap f) 1 ↔ x✝ ∈ 1
Theorem: StrictConvex.affine_image
File: Mathlib/Analysis/Convex/Strict.lean

tactic: rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩ hxy a b ha hb hab
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.205460
E : Type u_2
F : Type u_3
β : Type ?u.205469
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x y : E
hs : StrictConvex 𝕜 s
f : E →ᵃ[𝕜] F
hf : IsOpenMap ↑f
⊢ StrictConvex 𝕜 (↑f '' s)

tactic: exact
  hf.image_interior_subset _
    ⟨a • x + b • y, ⟨hs hx hy (ne_of_apply_ne _ hxy) ha hb hab, Convex.combo_affine_apply hab⟩⟩
state_before: case intro.intro.intro.intro
𝕜 : Type u_1
𝕝 : Type ?u.205460
E : Type u_2
F : Type u_3
β : Type ?u.205469
inst✝⁶ : OrderedRing 𝕜
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ : E
hs : StrictConvex 𝕜 s
f : E →ᵃ[𝕜] F
hf : IsOpenMap ↑f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : ↑f x ≠ ↑f y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • ↑f x + b • ↑f y ∈ interior (↑f '' s)
Theorem: sub_smul_slope_vadd
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

tactic: rw [sub_smul_slope, vsub_vadd]
state_before: k : Type u_3
E : Type u_2
PE : Type u_1
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b : k
⊢ (b - a) • slope f a b +ᵥ f a = f b
Theorem: sdiff_le_sdiff_of_sup_le_sup_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← sup_sdiff_right_self, ← @sup_sdiff_right_self _ _ b]
state_before: ι : Type ?u.142580
α : Type u_1
β : Type ?u.142586
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : a ⊔ c ≤ b ⊔ c
⊢ a \ c ≤ b \ c

tactic: exact sdiff_le_sdiff_right h
state_before: ι : Type ?u.142580
α : Type u_1
β : Type ?u.142586
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : a ⊔ c ≤ b ⊔ c
⊢ (a ⊔ c) \ c ≤ (b ⊔ c) \ c
Theorem: List.mergeSort_nil
File: Mathlib/Data/List/Sort.lean

tactic: rw [List.mergeSort]
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
⊢ mergeSort r [] = []
Theorem: MeasureTheory.average_zero
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: rw [average, integral_zero]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.178579
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ : Measure α
s : Set E
⊢ (⨍ (x : α), 0 ∂μ) = 0
Theorem: le_iff_exists_sup
File: Mathlib/Order/Lattice.lean

tactic: constructor
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ≤ b ↔ ∃ c, b = a ⊔ c

tactic: intro h
state_before: case mp
α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ≤ b → ∃ c, b = a ⊔ c

tactic: exact ⟨b, (sup_eq_right.mpr h).symm⟩
state_before: case mp
α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
h : a ≤ b
⊢ ∃ c, b = a ⊔ c

tactic: rintro ⟨c, rfl : _ = _ ⊔ _⟩
state_before: case mpr
α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ (∃ c, b = a ⊔ c) → a ≤ b

tactic: exact le_sup_left
state_before: case mpr.intro
α : Type u
β : Type v
inst✝ : SemilatticeSup α
a c✝ d c : α
⊢ a ≤ a ⊔ c
Theorem: CstarRing.star_mul_self_ne_zero_iff
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: simp only [Ne.def, star_mul_self_eq_zero_iff]
state_before: 𝕜 : Type ?u.42462
E : Type u_1
α : Type ?u.42468
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ x⋆ * x ≠ 0 ↔ x ≠ 0
Theorem: isEmpty_psigma
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_psigma, not_exists]
state_before: α✝ : Sort ?u.2642
β : Sort ?u.2645
γ : Sort ?u.2648
α : Sort u_1
E : α → Sort u_2
⊢ IsEmpty (PSigma E) ↔ ∀ (a : α), IsEmpty (E a)