tasksource/leandojo huggingface dataset:
Theorem: Filter.HasBasis.tendsto_left_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [Tendsto, (hla.map f).le_iff, image_subset_iff]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.69837
ι : Sort u_2
ι' : Sort ?u.69843
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hla : HasBasis la pa sa
⊢ Tendsto f la lb ↔ ∀ (t : Set β), t ∈ lb → ∃ i, pa i ∧ MapsTo f (sa i) t

tactic: rfl
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.69837
ι : Sort u_2
ι' : Sort ?u.69843
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hla : HasBasis la pa sa
⊢ (∀ (t : Set β), t ∈ lb → ∃ i, pa i ∧ sa i ⊆ f ⁻¹' t) ↔ ∀ (t : Set β), t ∈ lb → ∃ i, pa i ∧ MapsTo f (sa i) t
Theorem: CategoryTheory.eval_map
File: Mathlib/CategoryTheory/Sites/Types.lean

tactic: simp_rw [eval, ← FunctorToTypes.map_comp_apply, ← op_comp]
state_before: S : Type uᵒᵖ ⥤ Type u
α β : Type u
f : β ⟶ α
s : S.obj α.op
x : β
⊢ eval S β (S.map f.op s) x = eval S α s (f x)

tactic: rfl
state_before: S : Type uᵒᵖ ⥤ Type u
α β : Type u
f : β ⟶ α
s : S.obj α.op
x : β
⊢ S.map ((↾fun x_1 => x) ≫ f).op s = S.map (↾fun x_1 => f x).op s
Theorem: CategoryTheory.InjectiveResolution.homotopyEquiv_hom_ι
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: simp [homotopyEquiv]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X : C
I J : InjectiveResolution X
⊢ I.ι ≫ (homotopyEquiv I J).hom = J.ι
Theorem: Finset.zero_mul_subset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [subset_iff, mem_mul]
state_before: F : Type ?u.587676
α : Type u_1
β : Type ?u.587682
γ : Type ?u.587685
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : MulZeroClass α
s✝ t s : Finset α
⊢ 0 * s ⊆ 0
Theorem: Polynomial.revAt_add
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: rcases Nat.le.dest hn with ⟨n', rfl⟩
state_before: R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
N O n o : ℕ
hn : n ≤ N
ho : o ≤ O
⊢ ↑(revAt (N + O)) (n + o) = ↑(revAt N) n + ↑(revAt O) o

tactic: rcases Nat.le.dest ho with ⟨o', rfl⟩
state_before: case intro
R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
O n o : ℕ
ho : o ≤ O
n' : ℕ
hn : n ≤ n + n'
⊢ ↑(revAt (n + n' + O)) (n + o) = ↑(revAt (n + n')) n + ↑(revAt O) o

tactic: repeat' rw [revAt_le (le_add_right rfl.le)]
state_before: case intro.intro
R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ ↑(revAt (n + n' + (o + o'))) (n + o) = ↑(revAt (n + n')) n + ↑(revAt (o + o')) o

tactic: rw [add_assoc, add_left_comm n' o, ← add_assoc, revAt_le (le_add_right rfl.le)]
state_before: case intro.intro
R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ ↑(revAt (n + n' + (o + o'))) (n + o) = n + n' - n + (o + o' - o)

tactic: repeat' rw [add_tsub_cancel_left]
state_before: case intro.intro
R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ n + o + (n' + o') - (n + o) = n + n' - n + (o + o' - o)

tactic: rw [revAt_le (le_add_right rfl.le)]
state_before: case intro.intro
R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ ↑(revAt (n + n' + (o + o'))) (n + o) = n + n' - n + (o + o' - o)

tactic: rw [add_tsub_cancel_left]
state_before: case intro.intro
R : Type ?u.51822
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ n' + o' = n' + (o + o' - o)
Theorem: SimpleGraph.Iso.connectedComponentEquiv_trans
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext ⟨_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
⊢ connectedComponentEquiv (RelIso.trans φ φ') = (connectedComponentEquiv φ).trans (connectedComponentEquiv φ')

tactic: rfl
state_before: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
x✝ : ConnectedComponent G
a✝ : V
⊢ ↑(connectedComponentEquiv (RelIso.trans φ φ')) (Quot.mk (Reachable G) a✝) =
    ↑((connectedComponentEquiv φ).trans (connectedComponentEquiv φ')) (Quot.mk (Reachable G) a✝)
Theorem: Primrec.of_equiv_symm_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_2
β✝ : Type ?u.28291
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_1
e : β ≃ α
f : σ → α
this : Primcodable β := Primcodable.ofEquiv α e
h : Primrec fun a => ↑e.symm (f a)
a : σ
⊢ ↑e (↑e.symm (f a)) = f a
Theorem: LinearMap.range_eq_map
File: Mathlib/LinearAlgebra/Basic.lean

tactic: ext
state_before: R : Type u_1
R₁ : Type ?u.1060459
R₂ : Type u_2
R₃ : Type ?u.1060465
R₄ : Type ?u.1060468
S : Type ?u.1060471
K : Type ?u.1060474
K₂ : Type ?u.1060477
M : Type u_4
M' : Type ?u.1060483
M₁ : Type ?u.1060486
M₂ : Type u_3
M₃ : Type ?u.1060492
M₄ : Type ?u.1060495
N : Type ?u.1060498
N₂ : Type ?u.1060501
ι : Type ?u.1060504
V : Type ?u.1060507
V₂ : Type ?u.1060510
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
⊢ range f = map f ⊤

tactic: simp
state_before: case h
R : Type u_1
R₁ : Type ?u.1060459
R₂ : Type u_2
R₃ : Type ?u.1060465
R₄ : Type ?u.1060468
S : Type ?u.1060471
K : Type ?u.1060474
K₂ : Type ?u.1060477
M : Type u_4
M' : Type ?u.1060483
M₁ : Type ?u.1060486
M₂ : Type u_3
M₃ : Type ?u.1060492
M₄ : Type ?u.1060495
N : Type ?u.1060498
N₂ : Type ?u.1060501
ι : Type ?u.1060504
V : Type ?u.1060507
V₂ : Type ?u.1060510
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
x✝ : M₂
⊢ x✝ ∈ range f ↔ x✝ ∈ map f ⊤
Theorem: Nat.lcm_zero_left
File: Std/Data/Nat/Gcd.lean

tactic: simp [lcm]
state_before: m : Nat
⊢ lcm 0 m = 0
Theorem: SimpleGraph.Walk.map_isTrail_iff_of_injective
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ _ ih =>
  rw [map_cons, cons_isTrail_iff, ih, cons_isTrail_iff]
  apply and_congr_right'
  rw [← Sym2.map_pair_eq, edges_map, ← List.mem_map_of_injective (Sym2.map.injective hinj)]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
⊢ IsTrail (Walk.map f p) ↔ IsTrail p

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ : V
⊢ IsTrail (Walk.map f nil) ↔ IsTrail nil

tactic: rw [map_cons, cons_isTrail_iff, ih, cons_isTrail_iff]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsTrail (Walk.map f p✝) ↔ IsTrail p✝
⊢ IsTrail (Walk.map f (cons h✝ p✝)) ↔ IsTrail (cons h✝ p✝)

tactic: apply and_congr_right'
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsTrail (Walk.map f p✝) ↔ IsTrail p✝
⊢ IsTrail p✝ ∧ ¬Quotient.mk (Sym2.Rel.setoid V') (↑f u✝, ↑f v✝) ∈ edges (Walk.map f p✝) ↔
    IsTrail p✝ ∧ ¬Quotient.mk (Sym2.Rel.setoid V) (u✝, v✝) ∈ edges p✝

tactic: rw [← Sym2.map_pair_eq, edges_map, ← List.mem_map_of_injective (Sym2.map.injective hinj)]
state_before: case cons.h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hinj : Injective ↑f
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : IsTrail (Walk.map f p✝) ↔ IsTrail p✝
⊢ ¬Quotient.mk (Sym2.Rel.setoid V') (↑f u✝, ↑f v✝) ∈ edges (Walk.map f p✝) ↔
    ¬Quotient.mk (Sym2.Rel.setoid V) (u✝, v✝) ∈ edges p✝
Theorem: SimpleGraph.Walk.IsEulerian.card_odd_degree
File: Mathlib/Combinatorics/SimpleGraph/Trails.lean

tactic: rw [← Set.toFinset_card]
state_before: V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
p : Walk G u v
ht : IsEulerian p
⊢ Fintype.card ↑{v | Odd (degree G v)} = 0 ∨ Fintype.card ↑{v | Odd (degree G v)} = 2

tactic: apply IsEulerian.card_filter_odd_degree ht
state_before: V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
p : Walk G u v
ht : IsEulerian p
⊢ Finset.card (Set.toFinset {v | Odd (degree G v)}) = 0 ∨ Finset.card (Set.toFinset {v | Odd (degree G v)}) = 2

tactic: ext v
state_before: V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v : V
p : Walk G u v
ht : IsEulerian p
⊢ Set.toFinset {v | Odd (degree G v)} = Finset.filter (fun v => Odd (degree G v)) Finset.univ

tactic: simp
state_before: case a
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
u v✝ : V
p : Walk G u v✝
ht : IsEulerian p
v : V
⊢ v ∈ Set.toFinset {v | Odd (degree G v)} ↔ v ∈ Finset.filter (fun v => Odd (degree G v)) Finset.univ
Theorem: Order.Ideal.IsProper.not_mem_of_compl_mem
File: Mathlib/Order/Ideal.lean

tactic: intro hx
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsProper I
hxc : xᶜ ∈ I
⊢ ¬x ∈ I

tactic: apply hI.top_not_mem
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsProper I
hxc : xᶜ ∈ I
hx : x ∈ I
⊢ False

tactic: have ht : x ⊔ xᶜ ∈ I := sup_mem ‹_› ‹_›
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsProper I
hxc : xᶜ ∈ I
hx : x ∈ I
⊢ ⊤ ∈ I

tactic: rwa [sup_compl_eq_top] at ht
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsProper I
hxc : xᶜ ∈ I
hx : x ∈ I
ht : x ⊔ xᶜ ∈ I
⊢ ⊤ ∈ I
Theorem: Complex.tendsto_log_nhdsWithin_im_neg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: convert
  (continuous_ofReal.continuousAt.comp_continuousWithinAt
          (continuous_abs.continuousWithinAt.log _)).tendsto.add
    (((continuous_ofReal.tendsto _).comp <|
          tendsto_arg_nhdsWithin_im_neg_of_re_neg_of_im_zero hre him).mul
      tendsto_const_nhds) using 1
state_before: z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto log (𝓝[{z | z.im < 0}] z) (𝓝 (↑(Real.log (↑abs z)) - ↑π * I))

tactic: simp [sub_eq_add_neg]
state_before: case h.e'_5
z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ 𝓝 (↑(Real.log (↑abs z)) - ↑π * I) = 𝓝 ((ofReal' ∘ fun x => Real.log (↑abs x)) z + ↑(-π) * I)

tactic: lift z to ℝ using him
state_before: case convert_1
z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ ↑abs z ≠ 0

tactic: simpa using hre.ne
state_before: case convert_1.intro
z : ℝ
hre : (↑z).re < 0
⊢ ↑abs ↑z ≠ 0
Theorem: Subgroup.smul_opposite_image_mul_preimage'
File: Mathlib/GroupTheory/Subgroup/Pointwise.lean

tactic: simp [preimage_preimage, mul_assoc]
state_before: α : Type ?u.47334
G : Type u_1
A : Type ?u.47340
S : Type ?u.47343
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ : Set G
g : G
h : Gᵐᵒᵖ
s : Set G
⊢ (fun y => h • y) '' ((fun x => g * x) ⁻¹' s) = (fun x => g * x) ⁻¹' ((fun y => h • y) '' s)
Theorem: Real.sum_le_exp_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

tactic: refine' le_lim (CauSeq.le_of_exists ⟨n, fun j hj => _⟩)
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n : ℕ
⊢ ∑ i in range n, x ^ i / ↑i ! ≤
    CauSeq.lim { val := fun n => (↑(exp' ↑x) n).re, property := (_ : IsCauSeq abs' fun n => (↑(exp' ↑x) n).re) }

tactic: simp only [exp', const_apply, re_sum]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ↑(const abs' (∑ i in range n, x ^ i / ↑i !)) j ≤
    ↑{ val := fun n => (↑(exp' ↑x) n).re, property := (_ : IsCauSeq abs' fun n => (↑(exp' ↑x) n).re) } j

tactic: norm_cast
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i in range n, x ^ i / ↑i ! ≤ ∑ i in range j, (↑x ^ i / ↑i !).re

tactic: rw [← Nat.add_sub_of_le hj, Finset.sum_range_add]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i in range n, x ^ i / ↑i ! ≤ ∑ i in range j, x ^ i / ↑i !

tactic: refine' le_add_of_nonneg_right (sum_nonneg fun i _ => _)
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
⊢ ∑ i in range n, x ^ i / ↑i ! ≤
    ∑ x_1 in range n, x ^ x_1 / ↑x_1 ! + ∑ x_1 in range (j - n), x ^ (n + x_1) / ↑(n + x_1)!

tactic: positivity
state_before: x✝¹ y x : ℝ
hx : 0 ≤ x
n j : ℕ
hj : j ≥ n
i : ℕ
x✝ : i ∈ range (j - n)
⊢ 0 ≤ x ^ (n + i) / ↑(n + i)!

tactic: rw [exp, Complex.exp, ← cauSeqRe, lim_re]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
n : ℕ
⊢ CauSeq.lim { val := fun n => (↑(exp' ↑x) n).re, property := (_ : IsCauSeq abs' fun n => (↑(exp' ↑x) n).re) } = exp x
Theorem: Polynomial.support_update_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [update_zero_eq_erase, support_erase]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
⊢ support (update p n 0) = Finset.erase (support p) n
Theorem: Order.IsPredLimit.isMin
File: Mathlib/Order/SuccPred/Limit.lean

tactic: by_contra H
state_before: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : PredOrder α
h : IsPredLimit (pred a)
⊢ IsMin a

tactic: exact h a (pred_covby_of_not_isMin H)
state_before: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : PredOrder α
h : IsPredLimit (pred a)
H : ¬IsMin a
⊢ False
Theorem: AffineSubspace.direction_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: cases' S.Nonempty with p
state_before: k : Type u_2
V : Type u_1
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
⊢ direction ⊤ = ⊤

tactic: ext v
state_before: case intro
k : Type u_2
V : Type u_1
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
⊢ direction ⊤ = ⊤

tactic: refine' ⟨imp_intro Submodule.mem_top, fun _hv => _⟩
state_before: case intro.h
k : Type u_2
V : Type u_1
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
⊢ v ∈ direction ⊤ ↔ v ∈ ⊤

tactic: have hpv : (v +ᵥ p -ᵥ p : V) ∈ (⊤ : AffineSubspace k P).direction :=
  vsub_mem_direction (mem_top k V _) (mem_top k V _)
state_before: case intro.h
k : Type u_2
V : Type u_1
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
_hv : v ∈ ⊤
⊢ v ∈ direction ⊤

tactic: rwa [vadd_vsub] at hpv
state_before: case intro.h
k : Type u_2
V : Type u_1
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
_hv : v ∈ ⊤
hpv : v +ᵥ p -ᵥ p ∈ direction ⊤
⊢ v ∈ direction ⊤
Theorem: Function.IsFixedPt.preimage_iterate
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: rw [Set.preimage_iterate_eq]
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n✝ k : ℕ
e : Perm α
s : Set α
h : IsFixedPt (Set.preimage f) s
n : ℕ
⊢ IsFixedPt (Set.preimage (f^[n])) s

tactic: exact h.iterate n
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n✝ k : ℕ
e : Perm α
s : Set α
h : IsFixedPt (Set.preimage f) s
n : ℕ
⊢ IsFixedPt (Set.preimage f^[n]) s
Theorem: HasFTaylorSeriesUpTo.zero_eq'
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [← h.zero_eq x]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = ↑(LinearIsometryEquiv.symm (continuousMultilinearCurryFin0 𝕜 E F)) (f x)

tactic: exact (p x 0).uncurry0_curry0.symm
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = ↑(LinearIsometryEquiv.symm (continuousMultilinearCurryFin0 𝕜 E F)) (ContinuousMultilinearMap.uncurry0 (p x 0))
Theorem: List.inter_eq_nil_iff_disjoint
File: Mathlib/Data/List/Lattice.lean

tactic: simp only [eq_nil_iff_forall_not_mem, mem_inter, not_and]
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
⊢ l₁ ∩ l₂ = [] ↔ Disjoint l₁ l₂

tactic: rfl
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
⊢ (∀ (a : α), a ∈ l₁ → ¬a ∈ l₂) ↔ Disjoint l₁ l₂
Theorem: LieSubmodule.lieSpan_eq_bot_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [_root_.eq_bot_iff, lieSpan_le, bot_coe, subset_singleton_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
⊢ lieSpan R L s = ⊥ ↔ ∀ (m : M), m ∈ s → m = 0
Theorem: Finmap.insert_singleton_eq
File: Mathlib/Data/Finmap.lean

tactic: simp only [singleton, Finmap.insert_toFinmap, AList.insert_singleton_eq]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
⊢ insert a b (singleton a b') = singleton a b
Theorem: Array.reverse.termination
File: src/lean/Init/Data/Array/Basic.lean

tactic: rw [Nat.sub_sub, Nat.add_comm]
state_before: i j : Nat
h : i < j
⊢ j - 1 - (i + 1) < j - i

tactic: exact Nat.lt_of_le_of_lt (Nat.pred_le _) (Nat.sub_succ_lt_self _ _ h)
state_before: i j : Nat
h : i < j
⊢ j - (i + 1 + 1) < j - i
Theorem: zsmul_int_one
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp
state_before: α : Type ?u.285650
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
n : ℤ
⊢ n • 1 = n
Theorem: forall_eq_apply_imp_iff
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: ι : Sort ?u.19483
α : Sort ?u.19488
κ : ι → Sort ?u.19485
p✝ q : α → Prop
β : Sort u_1
f : α → β
p : β → Prop
⊢ (∀ (a : α) (b : β), b = f a → p b) ↔ ∀ (a : α), p (f a)
Theorem: ZFSet.mem_sep
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rwa [@Quotient.sound PSet _ _ _ h]
state_before: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : Quotient.mk setoid y ∈ ZFSet.sep p (Quotient.mk setoid (PSet.mk α A))
a : Type (PSet.mk α A)
pa : (fun y => p (mk y)) (Func (PSet.mk α A) a)
h :
  PSet.Equiv y
    (Func
      ↑(Resp.f
          { val := PSet.sep fun y => p (mk y),
            property :=
              (_ :
                ∀ (x x_1 : PSet),
                  PSet.Equiv x x_1 → Arity.Equiv (PSet.sep (fun y => p (mk y)) x) (PSet.sep (fun y => p (mk y)) x_1)) }
          (PSet.mk α A))
      { val := a, property := pa })
⊢ p (Quotient.mk setoid y)

tactic: rw [mk_func] at h
state_before: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : Quotient.mk setoid y ∈ Quotient.mk setoid (PSet.mk α A) ∧ p (Quotient.mk setoid y)
a : Type (PSet.mk α A)
h : PSet.Equiv y (Func (PSet.mk α A) a)
pa : p (Quotient.mk setoid y)
⊢ (fun y => p (mk y)) (Func (PSet.mk α A) a)

tactic: rwa [mk_func, ← ZFSet.sound h]
state_before: p : ZFSet → Prop
x y✝ : ZFSet
x✝¹ y : PSet
α : Type u
A : α → PSet
x✝ : Quotient.mk setoid y ∈ Quotient.mk setoid (PSet.mk α A) ∧ p (Quotient.mk setoid y)
a : Type (PSet.mk α A)
h : PSet.Equiv y (A a)
pa : p (Quotient.mk setoid y)
⊢ p (mk (Func (PSet.mk α A) a))
Theorem: Filter.not_tendsto_pow_atTop_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [not_tendsto_const_atBot]
state_before: ι : Type ?u.212695
ι' : Type ?u.212698
α : Type u_1
β : Type ?u.212704
γ : Type ?u.212707
inst✝ : LinearOrderedRing α
⊢ ¬Tendsto (fun x => x ^ 0) atTop atBot
Theorem: Nat.gcd_one_left
File: src/lean/Init/Data/Nat/Gcd.lean

tactic: rw [gcd_succ, mod_one]
state_before: n : Nat
⊢ gcd 1 n = 1

tactic: rfl
state_before: n : Nat
⊢ gcd 0 (succ 0) = 1
Theorem: Polynomial.Monic.of_mul_monic_right
File: Mathlib/Data/Polynomial/Monic.lean

tactic: contrapose! hpq
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hq : Monic q
hpq : Monic (p * q)
⊢ Monic p

tactic: rw [Monic.def] at hpq⊢
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hq : Monic q
hpq : ¬Monic p
⊢ ¬Monic (p * q)

tactic: rwa [leadingCoeff_mul_monic hq]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hq : Monic q
hpq : ¬Polynomial.leadingCoeff p = 1
⊢ ¬Polynomial.leadingCoeff (p * q) = 1
Theorem: MeasureTheory.measure_eq_iInf
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [measure_eq_trim, OuterMeasure.trim_eq_iInf]
state_before: α : Type u_1
β : Type ?u.10593
γ : Type ?u.10596
δ : Type ?u.10599
ι : Type ?u.10602
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
⊢ ↑↑μ s = ⨅ (t : Set α) (_ : s ⊆ t) (_ : MeasurableSet t), ↑↑μ t
Theorem: SimpleGraph.ConnectedComponent.iso_inv_image_comp_eq_iff_eq_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: refine' C.ind fun u => _
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
v : V
v' : V'
C : ConnectedComponent G
⊢ connectedComponentMk G (↑(Iso.symm φ) v') = C ↔
    connectedComponentMk G' v' = map (RelEmbedding.toRelHom (RelIso.toRelEmbedding φ)) C

tactic: simp only [Iso.symm_apply_reachable, ConnectedComponent.eq, ConnectedComponent.map_mk,
  RelEmbedding.coe_toRelHom, RelIso.coe_toRelEmbedding]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
v : V
v' : V'
C : ConnectedComponent G
u : V
⊢ connectedComponentMk G (↑(Iso.symm φ) v') = connectedComponentMk G u ↔
    connectedComponentMk G' v' = map (RelEmbedding.toRelHom (RelIso.toRelEmbedding φ)) (connectedComponentMk G u)
Theorem: Real.rpow_add'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases hx.eq_or_lt with (rfl | pos)
state_before: x y z : ℝ
hx : 0 ≤ x
h : y + z ≠ 0
⊢ x ^ (y + z) = x ^ y * x ^ z

tactic: rw [zero_rpow h, zero_eq_mul]
state_before: case inl
y z : ℝ
h : y + z ≠ 0
hx : 0 ≤ 0
⊢ 0 ^ (y + z) = 0 ^ y * 0 ^ z

tactic: have : y ≠ 0 ∨ z ≠ 0 := not_and_or.1 fun ⟨hy, hz⟩ => h <| hy.symm ▸ hz.symm ▸ zero_add 0
state_before: case inl
y z : ℝ
h : y + z ≠ 0
hx : 0 ≤ 0
⊢ 0 ^ y = 0 ∨ 0 ^ z = 0

tactic: exact this.imp zero_rpow zero_rpow
state_before: case inl
y z : ℝ
h : y + z ≠ 0
hx : 0 ≤ 0
this : y ≠ 0 ∨ z ≠ 0
⊢ 0 ^ y = 0 ∨ 0 ^ z = 0

tactic: exact rpow_add pos _ _
state_before: case inr
x y z : ℝ
hx : 0 ≤ x
h : y + z ≠ 0
pos : 0 < x
⊢ x ^ (y + z) = x ^ y * x ^ z