tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Functor.eventualRange_mapsTo
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: rw [mem_eventualRange_iff] at hx⊢
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : j ⟶ i
x : F.obj j
hx : x ∈ eventualRange F j
⊢ F.map f x ∈ eventualRange F i

tactic: intro k f'
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : j ⟶ i
x : F.obj j
hx : ∀ ⦃i : J⦄ (f : i ⟶ j), x ∈ range (F.map f)
⊢ ∀ ⦃i_1 : J⦄ (f_1 : i_1 ⟶ i), F.map f x ∈ range (F.map f_1)

tactic: obtain ⟨l, g, g', he⟩ := cospan f f'
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : j ⟶ i
x : F.obj j
hx : ∀ ⦃i : J⦄ (f : i ⟶ j), x ∈ range (F.map f)
k : J
f' : k ⟶ i
⊢ F.map f x ∈ range (F.map f')

tactic: obtain ⟨x, rfl⟩ := hx g
state_before: case intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : j ⟶ i
x : F.obj j
hx : ∀ ⦃i : J⦄ (f : i ⟶ j), x ∈ range (F.map f)
k : J
f' : k ⟶ i
l : J
g : l ⟶ j
g' : l ⟶ k
he : g ≫ f = g' ≫ f'
⊢ F.map f x ∈ range (F.map f')

tactic: rw [← map_comp_apply, he, F.map_comp]
state_before: case intro.intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : j ⟶ i
k : J
f' : k ⟶ i
l : J
g : l ⟶ j
g' : l ⟶ k
he : g ≫ f = g' ≫ f'
x : F.obj l
hx : ∀ ⦃i : J⦄ (f : i ⟶ j), F.map g x ∈ range (F.map f)
⊢ F.map f (F.map g x) ∈ range (F.map f')

tactic: exact ⟨_, rfl⟩
state_before: case intro.intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j k✝ : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
f : j ⟶ i
k : J
f' : k ⟶ i
l : J
g : l ⟶ j
g' : l ⟶ k
he : g ≫ f = g' ≫ f'
x : F.obj l
hx : ∀ ⦃i : J⦄ (f : i ⟶ j), F.map g x ∈ range (F.map f)
⊢ (F.map g' ≫ F.map f') x ∈ range (F.map f')
Theorem: Subadditive.apply_mul_add_le
File: Mathlib/Analysis/Subadditive.lean

tactic: induction k with
| zero => simp only [Nat.zero_eq, Nat.cast_zero, zero_mul, zero_add]; rfl
| succ k IH =>
  calc
    u ((k + 1) * n + r) = u (n + (k * n + r)) := by congr 1; ring
    _ ≤ u n + u (k * n + r) := h _ _
    _ ≤ u n + (k * u n + u r) := add_le_add_left IH _
    _ = (k + 1 : ℕ) * u n + u r := by simp; ring
state_before: u : ℕ → ℝ
h : Subadditive u
k n r : ℕ
⊢ u (k * n + r) ≤ ↑k * u n + u r

tactic: simp only [Nat.zero_eq, Nat.cast_zero, zero_mul, zero_add]
state_before: case zero
u : ℕ → ℝ
h : Subadditive u
n r : ℕ
⊢ u (Nat.zero * n + r) ≤ ↑Nat.zero * u n + u r

tactic: rfl
state_before: case zero
u : ℕ → ℝ
h : Subadditive u
n r : ℕ
⊢ u r ≤ u r

tactic: calc
  u ((k + 1) * n + r) = u (n + (k * n + r)) := by congr 1; ring
  _ ≤ u n + u (k * n + r) := h _ _
  _ ≤ u n + (k * u n + u r) := add_le_add_left IH _
  _ = (k + 1 : ℕ) * u n + u r := by simp; ring
state_before: case succ
u : ℕ → ℝ
h : Subadditive u
n r k : ℕ
IH : u (k * n + r) ≤ ↑k * u n + u r
⊢ u (Nat.succ k * n + r) ≤ ↑(Nat.succ k) * u n + u r

tactic: congr 1
state_before: u : ℕ → ℝ
h : Subadditive u
n r k : ℕ
IH : u (k * n + r) ≤ ↑k * u n + u r
⊢ u ((k + 1) * n + r) = u (n + (k * n + r))

tactic: ring
state_before: case e_a
u : ℕ → ℝ
h : Subadditive u
n r k : ℕ
IH : u (k * n + r) ≤ ↑k * u n + u r
⊢ (k + 1) * n + r = n + (k * n + r)

tactic: simp
state_before: u : ℕ → ℝ
h : Subadditive u
n r k : ℕ
IH : u (k * n + r) ≤ ↑k * u n + u r
⊢ u n + (↑k * u n + u r) = ↑(k + 1) * u n + u r

tactic: ring
state_before: u : ℕ → ℝ
h : Subadditive u
n r k : ℕ
IH : u (k * n + r) ≤ ↑k * u n + u r
⊢ u n + (↑k * u n + u r) = (↑k + 1) * u n + u r
Theorem: Finsupp.single_apply_mem
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rcases em (a = x) with (rfl | hx) <;> [simp; simp [single_eq_of_ne hx]]
state_before: α : Type u_2
β : Type ?u.47865
γ : Type ?u.47868
ι : Type ?u.47871
M : Type u_1
M' : Type ?u.47877
N : Type ?u.47880
P : Type ?u.47883
G : Type ?u.47886
H : Type ?u.47889
R : Type ?u.47892
S : Type ?u.47895
inst✝ : Zero M
a a' : α
b : M
x : α
⊢ ↑(single a b) x ∈ {0, b}
Theorem: mul_div_div_cancel
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← div_mul, mul_div_cancel''']
state_before: α : Type ?u.74232
β : Type ?u.74235
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a * b / (a / c) = b * c
Theorem: PGame.zero_lf_le
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lf_iff_exists_le]
state_before: x : PGame
⊢ 0 ⧏ x ↔ ∃ i, 0 ≤ moveLeft x i

tactic: simp
state_before: x : PGame
⊢ ((∃ i, 0 ≤ moveLeft x i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ moveLeft x i
Theorem: Set.image_update_Ico_right
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simpa using image_update_Ico f i (f i) b
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
b : α i
⊢ update f i '' Ico (f i) b = Ico f (update f i b)
Theorem: Polynomial.trailingDegree_one_le
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: rw [← C_1]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ 0 ≤ trailingDegree 1

tactic: exact le_trailingDegree_C
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ 0 ≤ trailingDegree (↑C 1)
Theorem: CategoryTheory.StructuredArrow.map_id
File: Mathlib/CategoryTheory/StructuredArrow.lean

tactic: rw [eq_mk f]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S S' S'' : D
Y Y' : C
T : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj f = f

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S S' S'' : D
Y Y' : C
T : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj (mk f.hom) = mk f.hom
Theorem: Nat.sub_right_comm
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.sub_sub, Nat.sub_sub, Nat.add_comm]
state_before: m n k : Nat
⊢ m - n - k = m - k - n
Theorem: LinearMap.toMatrix_mul
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [LinearMap.mul_eq_comp, LinearMap.toMatrix_comp v₁ v₁ v₁ f g]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.1900809
m : Type ?u.1900812
n : Type u_3
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type ?u.1900836
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.1901338
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f g : M₁ →ₗ[R] M₁
⊢ ↑(toMatrix v₁ v₁) (f * g) = ↑(toMatrix v₁ v₁) f ⬝ ↑(toMatrix v₁ v₁) g
Theorem: MeasureTheory.aestronglyMeasurable_zero_measure
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: nontriviality α
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285120
ι : Type ?u.285123
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
⊢ AEStronglyMeasurable f 0

tactic: inhabit α
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285120
ι : Type ?u.285123
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
✝ : Nontrivial α
⊢ AEStronglyMeasurable f 0

tactic: exact ⟨fun _ => f default, stronglyMeasurable_const, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.285120
ι : Type ?u.285123
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ AEStronglyMeasurable f 0
Theorem: Pmf.coe_le_one
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: refine' hasSum_le (fun b => _) (hasSum_ite_eq a (p a)) (hasSum_coe_one p)
state_before: α : Type u_1
β : Type ?u.16612
γ : Type ?u.16615
p : Pmf α
a : α
⊢ ↑p a ≤ 1

tactic: split_ifs with h <;> simp only [h, zero_le', le_rfl]
state_before: α : Type u_1
β : Type ?u.16612
γ : Type ?u.16615
p : Pmf α
a b : α
⊢ (if b = a then ↑p a else 0) ≤ ↑p b
Theorem: Polynomial.derivative_X_sub_C
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [derivative_sub, derivative_X, derivative_C, sub_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
c : R
⊢ ↑derivative (X - ↑C c) = 1
Theorem: edist_le_of_edist_le_geometric_of_tendsto₀
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simpa only [_root_.pow_zero, mul_one] using edist_le_of_edist_le_geometric_of_tendsto r C hu ha 0
state_before: α : Type u_1
β : Type ?u.436933
ι : Type ?u.436936
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
⊢ edist (f 0) a ≤ C / (1 - r)
Theorem: Turing.TM1.stmts_supportsStmt
File: Mathlib/Computability/TuringMachine.lean

tactic: simp only [stmts, Finset.mem_insertNone, Finset.mem_biUnion, Option.mem_def, Option.some.injEq,
  forall_eq', exists_imp, and_imp]
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
inst✝ : Inhabited Λ
M : Λ → Stmt₁
S : Finset Λ
q : Stmt₁
ss : Supports M S
⊢ some q ∈ stmts M S → SupportsStmt S q

tactic: exact fun l ls h ↦ stmts₁_supportsStmt_mono h (ss.2 _ ls)
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
inst✝ : Inhabited Λ
M : Λ → Stmt₁
S : Finset Λ
q : Stmt₁
ss : Supports M S
⊢ ∀ (x : Λ), x ∈ S → q ∈ stmts₁ (M x) → SupportsStmt S q
Theorem: List.takeI_left
File: Mathlib/Data/List/Basic.lean

tactic: simp only [length_append, Nat.le_add_right]
state_before: ι : Type ?u.226237
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : Inhabited α
l₁ l₂ : List α
⊢ length l₁ ≤ length (l₁ ++ l₂)
Theorem: List.prod_eq_pow_card
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [← prod_replicate, ← List.eq_replicate.mpr ⟨rfl, h⟩]
state_before: ι : Type ?u.16618
α : Type ?u.16621
M : Type u_1
N : Type ?u.16627
P : Type ?u.16630
M₀ : Type ?u.16633
G : Type ?u.16636
R : Type ?u.16639
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List M
m : M
h : ∀ (x : M), x ∈ l → x = m
⊢ prod l = m ^ length l
Theorem: MvPolynomial.finSuccEquiv_X_zero
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.978708
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
⊢ ↑(finSuccEquiv R n) (X 0) = Polynomial.X
Theorem: exists₂_comm
File: Mathlib/Logic/Basic.lean

tactic: simp only [@exists_comm (κ₁ _), @exists_comm ι₁]
state_before: ι : Sort ?u.20987
α : Sort ?u.20992
κ : ι → Sort ?u.20989
p✝ q : α → Prop
ι₁ : Sort u_1
ι₂ : Sort u_2
κ₁ : ι₁ → Sort u_3
κ₂ : ι₂ → Sort u_4
p : (i₁ : ι₁) → κ₁ i₁ → (i₂ : ι₂) → κ₂ i₂ → Prop
⊢ (∃ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∃ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂
Theorem: GroupWithZero.mul_right_injective
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simpa only [mul_assoc, mul_inv_cancel _ h, mul_one] using congr_arg (fun y => y * x⁻¹) w
state_before: α : Type ?u.18629
M₀ : Type ?u.18632
G₀ : Type u_1
M₀' : Type ?u.18638
G₀' : Type ?u.18641
F : Type ?u.18644
F' : Type ?u.18647
inst✝ : GroupWithZero G₀
a b c g h✝ x : G₀
h : x ≠ 0
y y' : G₀
w : (fun y => y * x) y = (fun y => y * x) y'
⊢ y = y'
Theorem: lineMap_strict_mono_right
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: simp only [lineMap_apply_module]
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.22259
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b < b'
hr : 0 < r
⊢ ↑(lineMap a b) r < ↑(lineMap a b') r

tactic: exact add_lt_add_left (smul_lt_smul_of_pos hb hr) _
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.22259
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b < b'
hr : 0 < r
⊢ (1 - r) • a + r • b < (1 - r) • a + r • b'
Theorem: inv_pow_sub₀
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: rw [pow_sub₀ _ (inv_ne_zero ha) h, inv_pow, inv_pow, inv_inv]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
⊢ a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n
Theorem: Finset.fold_max_lt
File: Mathlib/Data/Finset/Fold.lean

tactic: show _ > _ ↔ _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.70885
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ fold max b f s < c ↔ b < c ∧ ∀ (x : α), x ∈ s → f x < c

tactic: apply fold_op_rel_iff_and
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.70885
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ c > fold max b f s ↔ b < c ∧ ∀ (x : α), x ∈ s → f x < c

tactic: intro x y z
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.70885
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ ∀ {x y z : β}, x > max y z ↔ x > y ∧ x > z

tactic: show _ < _ ↔ _
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.70885
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c x y z : β
⊢ x > max y z ↔ x > y ∧ x > z

tactic: exact max_lt_iff
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.70885
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c x y z : β
⊢ max y z < x ↔ x > y ∧ x > z
Theorem: Monoid.exponent_eq_iSup_orderOf'
File: Mathlib/GroupTheory/Exponent.lean

tactic: split_ifs with h
state_before: G : Type u
inst✝ : CommMonoid G
⊢ exponent G = if ∃ g, orderOf g = 0 then 0 else ⨆ (g : G), orderOf g

tactic: obtain ⟨g, hg⟩ := h
state_before: case inl
G : Type u
inst✝ : CommMonoid G
h : ∃ g, orderOf g = 0
⊢ exponent G = 0

tactic: exact exponent_eq_zero_of_order_zero hg
state_before: case inl.intro
G : Type u
inst✝ : CommMonoid G
g : G
hg : orderOf g = 0
⊢ exponent G = 0

tactic: have := not_exists.mp h
state_before: case inr
G : Type u
inst✝ : CommMonoid G
h : ¬∃ g, orderOf g = 0
⊢ exponent G = ⨆ (g : G), orderOf g

tactic: exact exponent_eq_iSup_orderOf fun g => Ne.bot_lt <| this g
state_before: case inr
G : Type u
inst✝ : CommMonoid G
h : ¬∃ g, orderOf g = 0
this : ∀ (x : G), ¬orderOf x = 0
⊢ exponent G = ⨆ (g : G), orderOf g
Theorem: toIcoDiv_sub_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIcoDiv_add_zsmul', sub_neg_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoDiv hp (a - m • p) b = toIcoDiv hp a b + m
Theorem: interior_frontier
File: Mathlib/Topology/Basic.lean

tactic: have A : frontier s = s \ interior s := h.frontier_eq
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
⊢ interior (frontier s) = ∅

tactic: have B : interior (frontier s) ⊆ interior s := by rw [A]; exact interior_mono (diff_subset _ _)
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
⊢ interior (frontier s) = ∅

tactic: have C : interior (frontier s) ⊆ frontier s := interior_subset
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
⊢ interior (frontier s) = ∅

tactic: have : interior (frontier s) ⊆ interior s ∩ (s \ interior s) :=
  subset_inter B (by simpa [A] using C)
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
⊢ interior (frontier s) = ∅

tactic: rwa [inter_diff_self, subset_empty_iff] at this
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
this : interior (frontier s) ⊆ interior s ∩ (s \ interior s)
⊢ interior (frontier s) = ∅

tactic: rw [A]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
⊢ interior (frontier s) ⊆ interior s

tactic: exact interior_mono (diff_subset _ _)
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
⊢ interior (s \ interior s) ⊆ interior s

tactic: simpa [A] using C
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
⊢ interior (frontier s) ⊆ s \ interior s
Theorem: IsCoprime.ne_zero
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rintro rfl
state_before: R : Type u
inst✝¹ : CommSemiring R
x y z : R
inst✝ : Nontrivial R
p : Fin 2 → R
h : IsCoprime (p 0) (p 1)
⊢ p ≠ 0

tactic: exact not_isCoprime_zero_zero h
state_before: R : Type u
inst✝¹ : CommSemiring R
x y z : R
inst✝ : Nontrivial R
h : IsCoprime (OfNat.ofNat 0 0) (OfNat.ofNat 0 1)
⊢ False
Theorem: hom_coe_pow
File: Mathlib/Algebra/Hom/Iterate.lean

tactic: rw [pow_zero, h1]
state_before: M : Type u_2
N : Type ?u.17
G : Type ?u.20
H : Type ?u.23
F : Type u_1
inst✝ : Monoid F
c : F → M → M
h1 : c 1 = id
hmul : ∀ (f g : F), c (f * g) = c f ∘ c g
f : F
⊢ c (f ^ 0) = c f^[0]

tactic: rfl
state_before: M : Type u_2
N : Type ?u.17
G : Type ?u.20
H : Type ?u.23
F : Type u_1
inst✝ : Monoid F
c : F → M → M
h1 : c 1 = id
hmul : ∀ (f g : F), c (f * g) = c f ∘ c g
f : F
⊢ id = c f^[0]

tactic: rw [pow_succ, iterate_succ', hmul, hom_coe_pow c h1 hmul f n]
state_before: M : Type u_2
N : Type ?u.17
G : Type ?u.20
H : Type ?u.23
F : Type u_1
inst✝ : Monoid F
c : F → M → M
h1 : c 1 = id
hmul : ∀ (f g : F), c (f * g) = c f ∘ c g
f : F
n : ℕ
⊢ c (f ^ (n + 1)) = c f^[n + 1]
Theorem: Nat.binomial_one
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simp [multinomial_insert_one {b} f (Finset.not_mem_singleton.mpr h) h₁]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : a ≠ b
h₁ : f a = 1
⊢ multinomial {a, b} f = succ (f b)
Theorem: List.length_removeNth
File: Std/Data/List/Lemmas.lean

tactic: simp [removeNth]
state_before: α : Type u_1
head✝ : α
tail✝ : List α
x✝ : 0 < length (head✝ :: tail✝)
⊢ length (removeNth (head✝ :: tail✝) 0) = length (head✝ :: tail✝) - 1

tactic: have : i < length xs := Nat.lt_of_succ_lt_succ h
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < length (x :: xs)
⊢ length (removeNth (x :: xs) (i + 1)) = length (x :: xs) - 1

tactic: simp [removeNth, ← Nat.add_one]
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < length (x :: xs)
this : i < length xs
⊢ length (removeNth (x :: xs) (i + 1)) = length (x :: xs) - 1

tactic: rw [length_removeNth this, Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) this)]
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < length (x :: xs)
this : i < length xs
⊢ length (removeNth xs i) + 1 = length xs
Theorem: PrimeSpectrum.basicOpen_mul_le_left
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [basicOpen_mul f g]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f g : R
⊢ basicOpen (f * g) ≤ basicOpen f

tactic: exact inf_le_left
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f g : R
⊢ basicOpen f ⊓ basicOpen g ≤ basicOpen f
Theorem: LaurentPolynomial.induction_on_mul_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rcases f.exists_T_pow with ⟨n, f', hf⟩
state_before: R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (↑toLaurent f * T (-↑n))
⊢ Q f

tactic: rw [← mul_one f, ← T_zero, ← Nat.cast_zero, ← Nat.sub_self n, Nat.cast_sub rfl.le, T_sub,
  ← mul_assoc, ← hf]
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (↑toLaurent f * T (-↑n))
n : ℕ
f' : R[X]
hf : ↑toLaurent f' = f * T ↑n
⊢ Q f

tactic: exact Qf
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
f : R[T;T⁻¹]
Qf : ∀ {f : R[X]} {n : ℕ}, Q (↑toLaurent f * T (-↑n))
n : ℕ
f' : R[X]
hf : ↑toLaurent f' = f * T ↑n
⊢ Q (↑toLaurent f' * T (-↑n))
Theorem: homology.condition_π'
File: Mathlib/CategoryTheory/Abelian/Homology.lean

tactic: dsimp [π']
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ kernel.lift g f w ≫ π' f g w = 0

tactic: simp
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ kernel.lift g f w ≫ cokernel.π (kernel.lift g f w) ≫ (homologyIsoCokernelLift f g w).inv = 0
Theorem: Sym2.fromRel_bot
File: Mathlib/Data/Sym/Sym2.lean

tactic: apply Set.eq_empty_of_forall_not_mem fun e => _
state_before: α : Type u_1
β : Type ?u.42295
γ : Type ?u.42298
r : α → α → Prop
⊢ fromRel (_ : ∀ (x y : α), ⊥ x y → ⊥ x y) = ∅

tactic: apply Sym2.ind
state_before: α : Type u_1
β : Type ?u.42295
γ : Type ?u.42298
r : α → α → Prop
⊢ ∀ (e : Sym2 α), ¬e ∈ fromRel (_ : ∀ (x y : α), ⊥ x y → ⊥ x y)

tactic: simp [-Set.bot_eq_empty, Prop.bot_eq_false]
state_before: case h
α : Type u_1
β : Type ?u.42295
γ : Type ?u.42298
r : α → α → Prop
⊢ ∀ (x y : α), ¬Quotient.mk (Rel.setoid α) (x, y) ∈ fromRel (_ : ∀ (x y : α), ⊥ x y → ⊥ x y)
Theorem: EReal.add_lt_top
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← EReal.top_add_top]
state_before: x y : EReal
hx : x ≠ ⊤
hy : y ≠ ⊤
⊢ x + y < ⊤

tactic: exact EReal.add_lt_add hx.lt_top hy.lt_top
state_before: x y : EReal
hx : x ≠ ⊤
hy : y ≠ ⊤
⊢ x + y < ⊤ + ⊤
Theorem: orthogonalProjection_minimal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [norm_eq_iInf_iff_inner_eq_zero _ (Submodule.coe_mem _)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.503637
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : CompleteSpace { x // x ∈ K }
U : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
y : E
⊢ ‖y - ↑(↑(orthogonalProjection U) y)‖ = ⨅ (x : { x // x ∈ U }), ‖y - ↑x‖

tactic: exact orthogonalProjection_inner_eq_zero _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.503637
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : CompleteSpace { x // x ∈ K }
U : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
y : E
⊢ ∀ (w : E), w ∈ U → inner (y - ↑(↑(orthogonalProjection U) y)) w = 0
Theorem: OnePoint.isOpen_iff_of_not_mem
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp [isOpen_def, h]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ¬∞ ∈ s
⊢ IsOpen s ↔ IsOpen (some ⁻¹' s)
Theorem: IsGenericPoint.image
File: Mathlib/Topology/Sober.lean

tactic: rw [isGenericPoint_def, ← h.def, ← image_singleton, closure_image_closure hf]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
h : IsGenericPoint x S
f : α → β
hf : Continuous f
⊢ IsGenericPoint (f x) (closure (f '' S))