tasksource/leandojo huggingface dataset:
Theorem: notBelow_isOpen
File: Mathlib/Topology/OmegaCompletePartialOrder.lean

tactic: have h : Monotone (notBelow y) := by
  intro x y' h
  simp only [notBelow, setOf, le_Prop_eq]
  intro h₀ h₁
  apply h₀ (le_trans h h₁)
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
⊢ IsOpen (notBelow y)

tactic: exists h
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
h : Monotone (notBelow y)
⊢ IsOpen (notBelow y)

tactic: rintro c
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
h : Monotone (notBelow y)
⊢ OmegaCompletePartialOrder.Continuous { toFun := fun x => x ∈ notBelow y, monotone' := h }

tactic: apply eq_of_forall_ge_iff
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
h : Monotone (notBelow y)
c : Chain α
⊢ ↑{ toFun := fun x => x ∈ notBelow y, monotone' := h } (ωSup c) =
    ωSup (Chain.map c { toFun := fun x => x ∈ notBelow y, monotone' := h })

tactic: intro z
state_before: case H
α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
h : Monotone (notBelow y)
c : Chain α
⊢ ∀ (c_1 : Prop),
    ↑{ toFun := fun x => x ∈ notBelow y, monotone' := h } (ωSup c) ≤ c_1 ↔
      ωSup (Chain.map c { toFun := fun x => x ∈ notBelow y, monotone' := h }) ≤ c_1

tactic: rw [ωSup_le_iff]
state_before: case H
α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
h : Monotone (notBelow y)
c : Chain α
z : Prop
⊢ ↑{ toFun := fun x => x ∈ notBelow y, monotone' := h } (ωSup c) ≤ z ↔
    ωSup (Chain.map c { toFun := fun x => x ∈ notBelow y, monotone' := h }) ≤ z

tactic: simp only [ωSup_le_iff, notBelow, mem_setOf_eq, le_Prop_eq, OrderHom.coe_fun_mk, Chain.map_coe,
  Function.comp_apply, exists_imp, not_forall]
state_before: case H
α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
h : Monotone (notBelow y)
c : Chain α
z : Prop
⊢ ↑{ toFun := fun x => x ∈ notBelow y, monotone' := h } (ωSup c) ≤ z ↔
    ∀ (i : ℕ), ↑(Chain.map c { toFun := fun x => x ∈ notBelow y, monotone' := h }) i ≤ z

tactic: intro x y' h
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y : Scott α
⊢ Monotone (notBelow y)

tactic: simp only [notBelow, setOf, le_Prop_eq]
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y x y' : Scott α
h : x ≤ y'
⊢ notBelow y x ≤ notBelow y y'

tactic: intro h₀ h₁
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y x y' : Scott α
h : x ≤ y'
⊢ ¬x ≤ y → ¬y' ≤ y

tactic: apply h₀ (le_trans h h₁)
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
y x y' : Scott α
h : x ≤ y'
h₀ : ¬x ≤ y
h₁ : y' ≤ y
⊢ False
Theorem: exists_max_ideal_of_mem_nonunits
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: have : Ideal.span ({a} : Set α) ≠ ⊤ := by
  intro H
  rw [Ideal.span_singleton_eq_top] at H
  contradiction
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
⊢ ∃ I, Ideal.IsMaximal I ∧ a ∈ I

tactic: rcases Ideal.exists_le_maximal _ this with ⟨I, Imax, H⟩
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
⊢ ∃ I, Ideal.IsMaximal I ∧ a ∈ I

tactic: use I, Imax
state_before: case intro.intro
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : Ideal.IsMaximal I
H : Ideal.span {a} ≤ I
⊢ ∃ I, Ideal.IsMaximal I ∧ a ∈ I

tactic: apply H
state_before: case intro.intro
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : Ideal.IsMaximal I
H : Ideal.span {a} ≤ I
⊢ a ∈ I

tactic: apply Ideal.subset_span
state_before: case intro.intro.a
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : Ideal.IsMaximal I
H : Ideal.span {a} ≤ I
⊢ a ∈ Ideal.span {a}

tactic: exact Set.mem_singleton a
state_before: case intro.intro.a.a
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : Ideal.IsMaximal I
H : Ideal.span {a} ≤ I
⊢ a ∈ {a}

tactic: intro H
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
⊢ Ideal.span {a} ≠ ⊤

tactic: rw [Ideal.span_singleton_eq_top] at H
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
H : Ideal.span {a} = ⊤
⊢ False

tactic: contradiction
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
H : IsUnit a
⊢ False
Theorem: Nat.bit0_div_two
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [← Nat.bit0_eq_bit0, bit0_eq_two_mul, two_mul_div_two_of_even (even_bit0 n)]
state_before: m n : ℕ
⊢ bit0 n / 2 = n
Theorem: Nat.dvd_div_of_mul_dvd
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: simp [ha]
state_before: a✝ b✝ m n k a b c : ℕ
h : a * b ∣ c
ha : a = 0
⊢ b ∣ c / a

tactic: simpa [mul_assoc] using hd
state_before: a✝ b✝ m n k a b c : ℕ
h : a * b ∣ c
ha✝ : ¬a = 0
ha : 0 < a
h1 : ∃ d, c = a * b * d
d : ℕ
hd : c = a * b * d
⊢ c = a * (b * d)
Theorem: Filter.tendsto_nhds
File: Mathlib/Topology/Filter.lean

tactic: simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
state_before: ι : Sort ?u.5011
α : Type u_1
β : Type u_2
X : Type ?u.5020
Y : Type ?u.5023
la : Filter α
lb : Filter β
f : α → Filter β
⊢ Tendsto f la (𝓝 lb) ↔ ∀ (s : Set β), s ∈ lb → ∀ᶠ (a : α) in la, s ∈ f a
Theorem: lp.hasSum_norm
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [norm_rpow_eq_tsum hp]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
⊢ HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) (‖f‖ ^ ENNReal.toReal p)

tactic: exact ((lp.memℓp f).summable hp).hasSum
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
⊢ HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) (∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p)
Theorem: InnerProductGeometry.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
⊢ Real.cos (angle x (x - y)) = ‖x‖ / ‖x - y‖

tactic: rw [sub_eq_add_neg, cos_angle_add_of_inner_eq_zero h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
⊢ Real.cos (angle x (x - y)) = ‖x‖ / ‖x - y‖
Theorem: Int.sub_emod
File: Std/Data/Int/DivMod.lean

tactic: apply (emod_add_cancel_right b).mp
state_before: a b n : Int
⊢ (a - b) % n = (a % n - b % n) % n

tactic: rw [Int.sub_add_cancel, ← Int.add_emod_emod, Int.sub_add_cancel, emod_emod]
state_before: a b n : Int
⊢ (a - b + b) % n = (a % n - b % n + b) % n
Theorem: Multiset.map_add_left_Icc
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: classical rw [Icc, Icc, ← Finset.image_add_left_Icc, Finset.image_val,
    ((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map ((fun x x_1 => x + x_1) c) (Icc a b) = Icc (c + a) (c + b)

tactic: rw [Icc, Icc, ← Finset.image_add_left_Icc, Finset.image_val,
((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map ((fun x x_1 => x + x_1) c) (Icc a b) = Icc (c + a) (c + b)
Theorem: GaloisInsertion.l_sup_u
File: Mathlib/Order/GaloisConnection.lean

tactic: simp only [gi.l_u_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.37330
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
gi : GaloisInsertion l u
a b : β
⊢ l (u a) ⊔ l (u b) = a ⊔ b
Theorem: Set.Nontrivial.infsep_lt_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type ?u.59186
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : Set.Nontrivial s
⊢ infsep s < d ↔ ∃ x x_1 y x_2 _hxy, dist x y < d

tactic: push_neg
state_before: α : Type u_1
β : Type ?u.59186
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : Set.Nontrivial s
⊢ ¬infsep s < d ↔ ¬∃ x x_1 y x_2 _hxy, dist x y < d

tactic: exact hs.le_infsep_iff
state_before: α : Type u_1
β : Type ?u.59186
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : Set.Nontrivial s
⊢ d ≤ infsep s ↔ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → d ≤ dist x y
Theorem: mul_add_mul_le_mul_add_mul'
File: Mathlib/Algebra/Order/Ring/Canonical.lean

tactic: rw [add_comm (a • d), add_comm (a • c)]
state_before: α : Type u
β : Type ?u.5132
inst✝¹ : StrictOrderedSemiring α
a b c d : α
inst✝ : ExistsAddOfLE α
hba : b ≤ a
hdc : d ≤ c
⊢ a • d + b • c ≤ a • c + b • d

tactic: exact mul_add_mul_le_mul_add_mul hba hdc
state_before: α : Type u
β : Type ?u.5132
inst✝¹ : StrictOrderedSemiring α
a b c d : α
inst✝ : ExistsAddOfLE α
hba : b ≤ a
hdc : d ≤ c
⊢ b • c + a • d ≤ b • d + a • c
Theorem: Set.Infinite.exists_ne_map_eq_of_mapsTo
File: Mathlib/Data/Set/Finite.lean

tactic: contrapose! ht
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
f : α → β
hs : Set.Infinite s
hf : MapsTo f s t
ht : Set.Finite t
⊢ ∃ x, x ∈ s ∧ ∃ y, y ∈ s ∧ x ≠ y ∧ f x = f y

tactic: exact infinite_of_injOn_mapsTo (fun x hx y hy => not_imp_not.1 (ht x hx y hy)) hf hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
f : α → β
hs : Set.Infinite s
hf : MapsTo f s t
ht : ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → f x ≠ f y
⊢ ¬Set.Finite t
Theorem: LiouvilleWith.add_rat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: simpa using h.add_rat (-r)
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
h : LiouvilleWith p (x + ↑r)
⊢ LiouvilleWith p x
Theorem: Lists'.cons_subset
File: Mathlib/SetTheory/Lists.lean

tactic: refine' ⟨fun h => _, fun ⟨⟨a', m, e⟩, s⟩ => Subset.cons e m s⟩
state_before: α : Type u_1
a : Lists α
l₁ l₂ : Lists' α true
⊢ cons a l₁ ⊆ l₂ ↔ a ∈ l₂ ∧ l₁ ⊆ l₂

tactic: generalize h' : Lists'.cons a l₁ = l₁' at h
state_before: α : Type u_1
a : Lists α
l₁ l₂ : Lists' α true
h : cons a l₁ ⊆ l₂
⊢ a ∈ l₂ ∧ l₁ ⊆ l₂

tactic: cases' h with l a' a'' l l' e m s
state_before: α : Type u_1
a : Lists α
l₁ l₂ l₁' : Lists' α true
h' : cons a l₁ = l₁'
h : l₁' ⊆ l₂
⊢ a ∈ l₂ ∧ l₁ ⊆ l₂

tactic: cases a
state_before: case cons
α : Type u_1
a : Lists α
l₁ l₂ : Lists' α true
a' a'' : Lists α
l : Lists' α true
e : a' ~ a''
h' : cons a l₁ = cons a' l
m : a'' ∈ toList l₂
s : Subset l l₂
⊢ a ∈ l₂ ∧ l₁ ⊆ l₂

tactic: cases a'
state_before: case cons.mk
α : Type u_1
l₁ l₂ : Lists' α true
a' a'' : Lists α
l : Lists' α true
e : a' ~ a''
m : a'' ∈ toList l₂
s : Subset l l₂
fst✝ : Bool
snd✝ : Lists' α fst✝
h' : cons { fst := fst✝, snd := snd✝ } l₁ = cons a' l
⊢ { fst := fst✝, snd := snd✝ } ∈ l₂ ∧ l₁ ⊆ l₂

tactic: cases h'
state_before: case cons.mk.mk
α : Type u_1
l₁ l₂ : Lists' α true
a'' : Lists α
l : Lists' α true
m : a'' ∈ toList l₂
s : Subset l l₂
fst✝¹ : Bool
snd✝¹ : Lists' α fst✝¹
fst✝ : Bool
snd✝ : Lists' α fst✝
e : { fst := fst✝, snd := snd✝ } ~ a''
h' : cons { fst := fst✝¹, snd := snd✝¹ } l₁ = cons { fst := fst✝, snd := snd✝ } l
⊢ { fst := fst✝¹, snd := snd✝¹ } ∈ l₂ ∧ l₁ ⊆ l₂

tactic: exact ⟨⟨_, m, e⟩, s⟩
state_before: case cons.mk.mk.refl
α : Type u_1
l₁ l₂ : Lists' α true
a'' : Lists α
m : a'' ∈ toList l₂
fst✝ : Bool
snd✝ : Lists' α fst✝
e : { fst := fst✝, snd := snd✝ } ~ a''
s : Subset l₁ l₂
⊢ { fst := fst✝, snd := snd✝ } ∈ l₂ ∧ l₁ ⊆ l₂

tactic: cases a
state_before: case nil
α : Type u_1
a : Lists α
l₁ l₂ : Lists' α true
h' : cons a l₁ = nil
⊢ a ∈ l₂ ∧ l₁ ⊆ l₂

tactic: cases h'
state_before: case nil.mk
α : Type u_1
l₁ l₂ : Lists' α true
fst✝ : Bool
snd✝ : Lists' α fst✝
h' : cons { fst := fst✝, snd := snd✝ } l₁ = nil
⊢ { fst := fst✝, snd := snd✝ } ∈ l₂ ∧ l₁ ⊆ l₂
Theorem: PiNat.apply_eq_of_lt_firstDiff
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rw [firstDiff_def] at hn
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hn : n < firstDiff x y
⊢ x n = y n

tactic: split_ifs at hn with h
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hn : n < if h : x ≠ y then Nat.find (_ : ∃ a, x a ≠ y a) else 0
⊢ x n = y n

tactic: convert Nat.find_min (ne_iff.1 h) hn
state_before: case inl
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : x ≠ y
hn : n < Nat.find (_ : ∃ a, x a ≠ y a)
⊢ x n = y n

tactic: simp
state_before: case a
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : x ≠ y
hn : n < Nat.find (_ : ∃ a, x a ≠ y a)
⊢ x n = y n ↔ ¬x n ≠ y n

tactic: exact (not_lt_zero' hn).elim
state_before: case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : ¬x ≠ y
hn : n < 0
⊢ x n = y n
Theorem: Set.preimage_sub_const_Ioi
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) ⁻¹' Ioi b = Ioi (b + a)
Theorem: CategoryTheory.Under.UnderMorphism.ext
File: Mathlib/CategoryTheory/Over.lean

tactic: let ⟨_,b,_⟩ := f
state_before: T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Under X
f g : U ⟶ V
h : f.right = g.right
⊢ f = g

tactic: let ⟨_,e,_⟩ := g
state_before: T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map b
h : (CommaMorphism.mk left✝ b).right = g.right
⊢ CommaMorphism.mk left✝ b = g

tactic: congr
state_before: T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (Functor.fromPUnit X).map left✝¹ ≫ V.hom = U.hom ≫ (𝟭 T).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map e
h : (CommaMorphism.mk left✝¹ b).right = (CommaMorphism.mk left✝ e).right
⊢ CommaMorphism.mk left✝¹ b = CommaMorphism.mk left✝ e

tactic: simp only [eq_iff_true_of_subsingleton]
state_before: case e_left
T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (Functor.fromPUnit X).map left✝¹ ≫ V.hom = U.hom ≫ (𝟭 T).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map e
h : (CommaMorphism.mk left✝¹ b).right = (CommaMorphism.mk left✝ e).right
⊢ left✝¹ = left✝
Theorem: Equiv.Perm.sameCycle_one
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [SameCycle]
state_before: ι : Type ?u.31727
α : Type u_1
β : Type ?u.31733
f g : Perm α
p : α → Prop
x y z : α
⊢ SameCycle 1 x y ↔ x = y
Theorem: Ordinal.lt_div
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← not_le, div_le h, not_lt]
state_before: α : Type ?u.232451
β : Type ?u.232454
γ : Type ?u.232457
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : c ≠ 0
⊢ a < b / c ↔ c * succ a ≤ b
Theorem: Finset.card_pow_div_pow_le'
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [← card_inv, inv_div', ← inv_pow, ← inv_pow, div_eq_mul_inv A]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A B✝ C : Finset α
hA : Finset.Nonempty A
B : Finset α
m n : ℕ
⊢ ↑(card (B ^ m / B ^ n)) ≤ (↑(card (A / B)) / ↑(card A)) ^ (m + n) * ↑(card A)

tactic: exact card_pow_div_pow_le hA _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A B✝ C : Finset α
hA : Finset.Nonempty A
B : Finset α
m n : ℕ
⊢ ↑(card (B⁻¹ ^ m / B⁻¹ ^ n)) ≤ (↑(card (A * B⁻¹)) / ↑(card A)) ^ (m + n) * ↑(card A)
Theorem: Filter.image_mem_of_mem_comap
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← map_comap_of_mem h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.259120
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ f

tactic: exact image_mem_map W_in
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.259120
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ map c (comap c f)
Theorem: AlgebraicGeometry.SheafedSpace.id_c_app
File: Mathlib/AlgebraicGeometry/SheafedSpace.lean

tactic: aesop_cat
state_before: C : Type u
inst✝ : Category C
X : SheafedSpace C
U : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
⊢ X.presheaf.obj U = ((𝟙 X).base _* X.presheaf).obj U

tactic: aesop_cat
state_before: C : Type u
inst✝ : Category C
X : SheafedSpace C
U : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
⊢ (𝟙 X).c.app U =
    eqToHom (_ : X.presheaf.obj U = X.presheaf.obj ((Functor.op (Opens.map (𝟙 ↑X.toPresheafedSpace))).obj U))
Theorem: Complex.conj_bit0
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [bit0]
state_before: z : ℂ
⊢ (↑(starRingEnd ℂ) (bit0 z)).re = (bit0 (↑(starRingEnd ℂ) z)).re ∧
    (↑(starRingEnd ℂ) (bit0 z)).im = (bit0 (↑(starRingEnd ℂ) z)).im
Theorem: Hyperreal.IsSt.inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rintro rfl
state_before: x : ℝ*
r : ℝ
hi : ¬Infinitesimal x
hr : IsSt x r
⊢ r ≠ 0

tactic: exact hi hr
state_before: x : ℝ*
hi : ¬Infinitesimal x
hr : IsSt x 0
⊢ False
Theorem: RingQuot.Rel.smul
File: Mathlib/Algebra/RingQuot.lean

tactic: simp only [Algebra.smul_def, Rel.mul_right h]
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : A → A → Prop
k : S
a b : A
h : Rel r a b
⊢ Rel r (k • a) (k • b)
Theorem: Sylow.normalizer_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: have := normal_of_normalizer_normal (P.subtype (le_normalizer.trans le_normalizer))
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
⊢ normalizer (normalizer ↑P) = normalizer ↑P

tactic: simp_rw [← normalizer_eq_top, Sylow.coe_subtype, ← subgroupOf_normalizer_eq le_normalizer, ←
  subgroupOf_normalizer_eq le_rfl, subgroupOf_self] at this
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this :
  Normal (normalizer ↑(Sylow.subtype P (_ : ↑P ≤ normalizer (normalizer ↑P)))) →
    Normal ↑(Sylow.subtype P (_ : ↑P ≤ normalizer (normalizer ↑P)))
⊢ normalizer (normalizer ↑P) = normalizer ↑P

tactic: rw [← subtype_range (P : Subgroup G).normalizer.normalizer, MonoidHom.range_eq_map,
  ← this trivial]
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → subgroupOf (normalizer ↑P) (normalizer (normalizer ↑P)) = ⊤
⊢ normalizer (normalizer ↑P) = normalizer ↑P

tactic: exact map_comap_eq_self (le_normalizer.trans (ge_of_eq (subtype_range _)))
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → subgroupOf (normalizer ↑P) (normalizer (normalizer ↑P)) = ⊤
⊢ Subgroup.map (Subgroup.subtype (normalizer (normalizer ↑P)))
      (subgroupOf (normalizer ↑P) (normalizer (normalizer ↑P))) =
    normalizer ↑P
Theorem: Set.Icc_self
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [Icc, le_antisymm_iff, and_comm]
state_before: α : Type u_1
β : Type ?u.30276
inst✝ : PartialOrder α
a✝ b c a : α
⊢ ∀ (x : α), x ∈ Icc a a ↔ x ∈ {a}
Theorem: SimpleGraph.set_walk_length_toFinset_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext p
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : LocallyFinite G
n : ℕ
u v : V
⊢ Set.toFinset {p | Walk.length p = n} = finsetWalkLength G n u v

tactic: simp [← coe_finsetWalkLength_eq]
state_before: case a
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : LocallyFinite G
n : ℕ
u v : V
p : Walk G u v
⊢ p ∈ Set.toFinset {p | Walk.length p = n} ↔ p ∈ finsetWalkLength G n u v
Theorem: Function.extend_one
File: Mathlib/Data/Pi/Algebra.lean

tactic: apply ite_self
state_before: I : Type u
α : Type u_3
β : Type u_2
γ : Type u_1
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : One γ
f : α → β
x✝ : β
⊢ extend f 1 1 x✝ = OfNat.ofNat 1 x✝
Theorem: Real.Angle.two_nsmul_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: simp_rw [← coe_nat_zsmul, Nat.cast_ofNat, two_zsmul_eq_iff]
state_before: ψ θ : Angle
⊢ 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑π
Theorem: Submodule.dualAnnihilator_top
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [eq_bot_iff]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
⊢ dualAnnihilator ⊤ = ⊥

tactic: intro v
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
⊢ dualAnnihilator ⊤ ≤ ⊥

tactic: simp_rw [mem_dualAnnihilator, mem_bot, mem_top, forall_true_left]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
v : Module.Dual R M
⊢ v ∈ dualAnnihilator ⊤ → v ∈ ⊥

tactic: exact fun h => LinearMap.ext h
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
v : Module.Dual R M
⊢ (∀ (w : M), ↑v w = 0) → v = 0
Theorem: Nat.sqrt_isSqrt
File: Mathlib/Data/Nat/Sqrt.lean

tactic: simp [IsSqrt]
state_before: n : ℕ
⊢ Nat.IsSqrt 0 (sqrt 0)

tactic: simp [IsSqrt]
state_before: n : ℕ
⊢ Nat.IsSqrt 1 (sqrt 1)

tactic: have h : ¬ (n + 2) ≤ 1 := by simp
state_before: n✝ n : ℕ
⊢ Nat.IsSqrt (n + 2) (sqrt (n + 2))

tactic: simp only [IsSqrt, sqrt, h, ite_false]
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ Nat.IsSqrt (n + 2) (sqrt (n + 2))

tactic: refine ⟨sqrt.iter_sq_le _ _, sqrt.lt_iter_succ_sq _ _ ?_⟩
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ sqrt.iter (n + 2) ((n + 2) / 2) * sqrt.iter (n + 2) ((n + 2) / 2) ≤ n + 2 ∧
    n + 2 < (sqrt.iter (n + 2) ((n + 2) / 2) + 1) * (sqrt.iter (n + 2) ((n + 2) / 2) + 1)

tactic: simp only [mul_add, add_mul, one_mul, mul_one, ← add_assoc]
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ n + 2 < ((n + 2) / 2 + 1) * ((n + 2) / 2 + 1)

tactic: rw [lt_add_one_iff, add_assoc, ← mul_two]
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ n + 2 < (n + 2) / 2 * ((n + 2) / 2) + (n + 2) / 2 + (n + 2) / 2 + 1

tactic: refine le_trans (div_add_mod' (n + 2) 2).ge ?_
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ n + 2 ≤ (n + 2) / 2 * ((n + 2) / 2) + (n + 2) / 2 * 2

tactic: rw [add_comm, add_le_add_iff_right, add_mod_right]
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ (n + 2) / 2 * 2 + (n + 2) % 2 ≤ (n + 2) / 2 * ((n + 2) / 2) + (n + 2) / 2 * 2

tactic: simp only [zero_lt_two, add_div_right, succ_mul_succ_eq]
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ n % 2 ≤ (n + 2) / 2 * ((n + 2) / 2)

tactic: refine le_trans (b := 1) ?_ ?_
state_before: n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ n % 2 ≤ n / 2 * (n / 2) + n / 2 + n / 2 + 1

tactic: simp
state_before: n✝ n : ℕ
⊢ ¬n + 2 ≤ 1

tactic: exact (lt_succ.1 $ mod_lt n zero_lt_two)
state_before: case refine_1
n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ n % 2 ≤ 1

tactic: simp only [le_add_iff_nonneg_left]
state_before: case refine_2
n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ 1 ≤ n / 2 * (n / 2) + n / 2 + n / 2 + 1

tactic: exact zero_le _
state_before: case refine_2
n✝ n : ℕ
h : ¬n + 2 ≤ 1
⊢ 0 ≤ n / 2 * (n / 2) + n / 2 + n / 2