tasksource/leandojo huggingface dataset:
Theorem: Polynomial.natDegree_hasseDeriv
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: cases' lt_or_le p.natDegree n with hn hn
state_before: R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
⊢ natDegree (↑(hasseDeriv n) p) = natDegree p - n

tactic: simpa [hasseDeriv_eq_zero_of_lt_natDegree, hn] using (tsub_eq_zero_of_le hn.le).symm
state_before: case inl
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : natDegree p < n
⊢ natDegree (↑(hasseDeriv n) p) = natDegree p - n

tactic: refine' map_natDegree_eq_sub _ _
state_before: case inr
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
⊢ natDegree (↑(hasseDeriv n) p) = natDegree p - n

tactic: exact fun h => hasseDeriv_eq_zero_of_lt_natDegree _ _
state_before: case inr.refine'_1
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
⊢ ∀ (f : R[X]), natDegree f < n → ↑(hasseDeriv n) f = 0

tactic: classical
  simp only [ite_eq_right_iff, Ne.def, natDegree_monomial, hasseDeriv_monomial]
  intro k c c0 hh
  rw [← nsmul_eq_mul, smul_eq_zero, Nat.choose_eq_zero_iff] at hh
  exact (tsub_eq_zero_of_le (Or.resolve_right hh c0).le).symm
state_before: case inr.refine'_2
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
⊢ ∀ (n_1 : ℕ) (c : R), c ≠ 0 → natDegree (↑(hasseDeriv n) (↑(monomial n_1) c)) = n_1 - n

tactic: simp only [ite_eq_right_iff, Ne.def, natDegree_monomial, hasseDeriv_monomial]
state_before: case inr.refine'_2
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
⊢ ∀ (n_1 : ℕ) (c : R), c ≠ 0 → natDegree (↑(hasseDeriv n) (↑(monomial n_1) c)) = n_1 - n

tactic: intro k c c0 hh
state_before: case inr.refine'_2
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
⊢ ∀ (n_1 : ℕ) (c : R), ¬c = 0 → ↑(choose n_1 n) * c = 0 → 0 = n_1 - n

tactic: rw [← nsmul_eq_mul, smul_eq_zero, Nat.choose_eq_zero_iff] at hh
state_before: case inr.refine'_2
R : Type u_1
inst✝¹ : Semiring R
k✝ : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
k : ℕ
c : R
c0 : ¬c = 0
hh : ↑(choose k n) * c = 0
⊢ 0 = k - n

tactic: exact (tsub_eq_zero_of_le (Or.resolve_right hh c0).le).symm
state_before: case inr.refine'_2
R : Type u_1
inst✝¹ : Semiring R
k✝ : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ natDegree p
k : ℕ
c : R
c0 : ¬c = 0
hh : k < n ∨ c = 0
⊢ 0 = k - n
Theorem: ContinuousLinearEquiv.comp_right_hasFDerivAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simp only [← hasFDerivWithinAt_univ, ← comp_right_hasFDerivWithinAt_iff, preimage_univ]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_3
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.203110
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
iso : E ≃L[𝕜] F
f : F → G
x : E
f' : F →L[𝕜] G
⊢ HasFDerivAt (f ∘ ↑iso) (comp f' ↑iso) x ↔ HasFDerivAt f f' (↑iso x)
Theorem: Finset.prod_powerset
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: rw [powerset_card_disjiUnion, prod_disjiUnion]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : Finset α → β
⊢ ∏ t in powerset s, f t = ∏ j in range (card s + 1), ∏ t in powersetLen j s, f t
Theorem: Compactum.lim_eq_str
File: Mathlib/Topology/Category/Compactum.lean

tactic: rw [Ultrafilter.lim_eq_iff_le_nhds, le_nhds_iff]
state_before: X : Compactum
F : Ultrafilter X.A
⊢ Ultrafilter.lim F = str X F

tactic: tauto
state_before: X : Compactum
F : Ultrafilter X.A
⊢ ∀ (s : Set X.A), str X F ∈ s → IsOpen s → s ∈ ↑F
Theorem: CategoryTheory.Endofunctor.Adjunction.Coalgebra.homEquiv_naturality_str_symm
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

tactic: rw [← Adjunction.homEquiv_naturality_left_symm, ← Adjunction.homEquiv_naturality_right_symm,
  f.h]
state_before: C : Type u
inst✝ : Category C
F G : C ⥤ C
adj : F ⊣ G
V₁ V₂ : Coalgebra G
f : V₁ ⟶ V₂
⊢ F.map f.f ≫ ↑(Adjunction.homEquiv adj V₂.V V₂.V).symm V₂.str = ↑(Adjunction.homEquiv adj V₁.V V₁.V).symm V₁.str ≫ f.f
Theorem: zero_pow_eq_zero
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: constructor <;> intro h
state_before: R : Type ?u.47966
S : Type ?u.47969
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : Nontrivial M
n : ℕ
⊢ 0 ^ n = 0 ↔ 0 < n

tactic: rw [pos_iff_ne_zero]
state_before: case mp
R : Type ?u.47966
S : Type ?u.47969
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : Nontrivial M
n : ℕ
h : 0 ^ n = 0
⊢ 0 < n

tactic: rintro rfl
state_before: case mp
R : Type ?u.47966
S : Type ?u.47969
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : Nontrivial M
n : ℕ
h : 0 ^ n = 0
⊢ n ≠ 0

tactic: simp at h
state_before: case mp
R : Type ?u.47966
S : Type ?u.47969
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : Nontrivial M
h : 0 ^ 0 = 0
⊢ False

tactic: exact zero_pow' n h.ne.symm
state_before: case mpr
R : Type ?u.47966
S : Type ?u.47969
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : Nontrivial M
n : ℕ
h : 0 < n
⊢ 0 ^ n = 0
Theorem: Polynomial.X_pow_add_C_ne_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [degree_X_pow_add_C hn a]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
⊢ degree (X ^ n + ↑C a) ≠ ⊥

tactic: exact WithBot.coe_ne_bot
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
hn : 0 < n
a : R
⊢ ↑n ≠ ⊥
Theorem: Monoid.mem_closure_union_iff
File: Mathlib/Deprecated/Submonoid.lean

tactic: rw [mul_assoc, List.prod_cons, ← hyzx]
state_before: M✝ : Type ?u.75380
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type ?u.75389
inst✝¹ : AddMonoid A
t✝ : Set A
M : Type u_1
inst✝ : CommMonoid M
s t : Set M
x : M
hx : x ∈ Closure (s ∪ t)
L : List M
HL1✝ : ∀ (x : M), x ∈ L → x ∈ s ∪ t
HL2 : List.prod L = x
hd : M
tl : List M
ih : (∀ (x : M), x ∈ tl → x ∈ s ∪ t) → ∃ y, y ∈ Closure s ∧ ∃ z, z ∈ Closure t ∧ y * z = List.prod tl
HL1 : ∀ (x : M), x ∈ hd :: tl → x ∈ s ∪ t
y : M
hy : y ∈ Closure s
z : M
hz : z ∈ Closure t
hyzx : y * z = List.prod tl
hs : hd ∈ s
⊢ hd * y * z = List.prod (hd :: tl)

tactic: rw [← mul_assoc, List.prod_cons, ← hyzx, mul_comm hd]
state_before: M✝ : Type ?u.75380
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type ?u.75389
inst✝¹ : AddMonoid A
t✝ : Set A
M : Type u_1
inst✝ : CommMonoid M
s t : Set M
x : M
hx : x ∈ Closure (s ∪ t)
L : List M
HL1✝ : ∀ (x : M), x ∈ L → x ∈ s ∪ t
HL2 : List.prod L = x
hd : M
tl : List M
ih : (∀ (x : M), x ∈ tl → x ∈ s ∪ t) → ∃ y, y ∈ Closure s ∧ ∃ z, z ∈ Closure t ∧ y * z = List.prod tl
HL1 : ∀ (x : M), x ∈ hd :: tl → x ∈ s ∪ t
y : M
hy : y ∈ Closure s
z : M
hz : z ∈ Closure t
hyzx : y * z = List.prod tl
ht : hd ∈ t
⊢ y * (z * hd) = List.prod (hd :: tl)
Theorem: LinearMap.rTensor_comp_map
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: simp only [lTensor, rTensor, ← map_comp, id_comp, comp_id]
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.1289962
inst✝¹³ : Monoid R'
R'' : Type ?u.1289968
inst✝¹² : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_2
Q : Type u_6
S : Type u_3
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g✝ : P →ₗ[R] Q
f✝ : N →ₗ[R] P
f' : P →ₗ[R] S
f : M →ₗ[R] P
g : N →ₗ[R] Q
⊢ comp (rTensor Q f') (map f g) = map (comp f' f) g
Theorem: Finset.Ioc_subset_Ioc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Ioc_subset_Ioc ha hb
state_before: ι : Type ?u.12902
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁
hb : b₁ ≤ b₂
⊢ Ioc a₁ b₁ ⊆ Ioc a₂ b₂
Theorem: Finpartition.biUnion_filter_atomise
File: Mathlib/Order/Partition/Finpartition.lean

tactic: ext a
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
⊢ Finset.biUnion (filter (fun u => u ⊆ t ∧ Finset.Nonempty u) (atomise s F).parts) id = t

tactic: refine' mem_biUnion.trans ⟨fun ⟨u, hu, ha⟩ ↦ (mem_filter.1 hu).2.1 ha, fun ha ↦ _⟩
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
a : α
⊢ a ∈ Finset.biUnion (filter (fun u => u ⊆ t ∧ Finset.Nonempty u) (atomise s F).parts) id ↔ a ∈ t

tactic: obtain ⟨u, hu, hau⟩ := (atomise s F).exists_mem (hts ha)
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
a : α
ha : a ∈ t
⊢ ∃ a_1, a_1 ∈ filter (fun u => u ⊆ t ∧ Finset.Nonempty u) (atomise s F).parts ∧ a ∈ id a_1

tactic: refine' ⟨u, mem_filter.2 ⟨hu, fun b hb ↦ _, _, hau⟩, hau⟩
state_before: case a.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
a : α
ha : a ∈ t
u : Finset α
hu : u ∈ (atomise s F).parts
hau : a ∈ u
⊢ ∃ a_1, a_1 ∈ filter (fun u => u ⊆ t ∧ Finset.Nonempty u) (atomise s F).parts ∧ a ∈ id a_1

tactic: obtain ⟨Q, _hQ, rfl⟩ := (mem_atomise.1 hu).2
state_before: case a.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
a : α
ha : a ∈ t
u : Finset α
hu : u ∈ (atomise s F).parts
hau : a ∈ u
b : α
hb : b ∈ u
⊢ b ∈ t

tactic: rw [mem_filter] at hau hb
state_before: case a.intro.intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
a : α
ha : a ∈ t
b : α
Q : Finset (Finset α)
_hQ : Q ⊆ F
hu : filter (fun i => ∀ (u : Finset α), u ∈ F → (u ∈ Q ↔ i ∈ u)) s ∈ (atomise s F).parts
hau : a ∈ filter (fun i => ∀ (u : Finset α), u ∈ F → (u ∈ Q ↔ i ∈ u)) s
hb : b ∈ filter (fun i => ∀ (u : Finset α), u ∈ F → (u ∈ Q ↔ i ∈ u)) s
⊢ b ∈ t

tactic: rwa [← hb.2 _ ht, hau.2 _ ht]
state_before: case a.intro.intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
ht : t ∈ F
hts : t ⊆ s
a : α
ha : a ∈ t
b : α
Q : Finset (Finset α)
_hQ : Q ⊆ F
hu : filter (fun i => ∀ (u : Finset α), u ∈ F → (u ∈ Q ↔ i ∈ u)) s ∈ (atomise s F).parts
hau : a ∈ s ∧ ∀ (u : Finset α), u ∈ F → (u ∈ Q ↔ a ∈ u)
hb : b ∈ s ∧ ∀ (u : Finset α), u ∈ F → (u ∈ Q ↔ b ∈ u)
⊢ b ∈ t
Theorem: List.bind_singleton'
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> simp [*]
state_before: ι : Type ?u.21722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
⊢ (List.bind l fun x => [x]) = l
Theorem: Polynomial.toSubring_zero
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp [frange_zero]
state_before: R : Type u
S : Type ?u.95871
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
⊢ ↑(frange 0) ⊆ ↑T

tactic: ext i
state_before: R : Type u
S : Type ?u.95871
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
⊢ toSubring 0 T (_ : ↑∅ ⊆ ↑T) = 0

tactic: simp
state_before: case a.a
R : Type u
S : Type ?u.95871
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
i : ℕ
⊢ ↑(coeff (toSubring 0 T (_ : ↑∅ ⊆ ↑T)) i) = ↑(coeff 0 i)
Theorem: Real.cos_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arccos, cos_pi_div_two_sub, sin_arcsin hx₁ hx₂]
state_before: x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arccos x) = x
Theorem: EuclideanDomain.div_add_mod'
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: rw [mul_comm]
state_before: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ m / k * k + m % k = m

tactic: exact div_add_mod _ _
state_before: R : Type u
inst✝ : EuclideanDomain R
m k : R
⊢ k * (m / k) + m % k = m
Theorem: euler_four_squares
File: Mathlib/NumberTheory/SumFourSquares.lean

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
a b c d x y z w : R
⊢ (a * x - b * y - c * z - d * w) ^ 2 + (a * y + b * x + c * w - d * z) ^ 2 + (a * z - b * w + c * x + d * y) ^ 2 +
      (a * w + b * z - c * y + d * x) ^ 2 =
    (a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2) * (x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2)
Theorem: normalize_eq_normalize
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a b : α
hab : a ∣ b
hba : b ∣ a
⊢ ↑normalize a = ↑normalize b

tactic: rcases associated_of_dvd_dvd hab hba with ⟨u, rfl⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a b : α
hab : a ∣ b
hba : b ∣ a
✝ : Nontrivial α
⊢ ↑normalize a = ↑normalize b

tactic: refine' by_cases (by rintro rfl; simp only [zero_mul]) fun ha : a ≠ 0 => _
state_before: case intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
u : αˣ
hab : a ∣ a * ↑u
hba : a * ↑u ∣ a
⊢ ↑normalize a = ↑normalize (a * ↑u)

tactic: suffices a * ↑(normUnit a) = a * ↑u * ↑(normUnit a) * ↑u⁻¹ by
  simpa only [normalize_apply, mul_assoc, normUnit_mul ha u.ne_zero, normUnit_coe_units]
state_before: case intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
u : αˣ
hab : a ∣ a * ↑u
hba : a * ↑u ∣ a
ha : a ≠ 0
⊢ ↑normalize a = ↑normalize (a * ↑u)

tactic: calc
  a * ↑(normUnit a) = a * ↑(normUnit a) * ↑u * ↑u⁻¹ := (Units.mul_inv_cancel_right _ _).symm
  _ = a * ↑u * ↑(normUnit a) * ↑u⁻¹ := by rw [mul_right_comm a]
state_before: case intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
u : αˣ
hab : a ∣ a * ↑u
hba : a * ↑u ∣ a
ha : a ≠ 0
⊢ a * ↑(normUnit a) = a * ↑u * ↑(normUnit a) * ↑u⁻¹

tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
u : αˣ
hab : a ∣ a * ↑u
hba : a * ↑u ∣ a
⊢ a = 0 → ↑normalize a = ↑normalize (a * ↑u)

tactic: simp only [zero_mul]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
✝ : Nontrivial α
u : αˣ
hab : 0 ∣ 0 * ↑u
hba : 0 * ↑u ∣ 0
⊢ ↑normalize 0 = ↑normalize (0 * ↑u)

tactic: simpa only [normalize_apply, mul_assoc, normUnit_mul ha u.ne_zero, normUnit_coe_units]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
u : αˣ
hab : a ∣ a * ↑u
hba : a * ↑u ∣ a
ha : a ≠ 0
this : a * ↑(normUnit a) = a * ↑u * ↑(normUnit a) * ↑u⁻¹
⊢ ↑normalize a = ↑normalize (a * ↑u)

tactic: rw [mul_right_comm a]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
u : αˣ
hab : a ∣ a * ↑u
hba : a * ↑u ∣ a
ha : a ≠ 0
⊢ a * ↑(normUnit a) * ↑u * ↑u⁻¹ = a * ↑u * ↑(normUnit a) * ↑u⁻¹
Theorem: QuotientMap.secondCountableTopology
File: Mathlib/Topology/Bases.lean

tactic: obtain ⟨V, V_countable, -, V_generates⟩ := exists_countable_basis X
state_before: α : Type u
t : TopologicalSpace α
X : Type u_1
inst✝² : TopologicalSpace X
Y : Type u_2
inst✝¹ : TopologicalSpace Y
π : X → Y
inst✝ : SecondCountableTopology X
h' : QuotientMap π
h : IsOpenMap π
⊢ ∃ b, Set.Countable b ∧ inst✝¹ = generateFrom b

tactic: exact ⟨Set.image π '' V, V_countable.image (Set.image π),
  (V_generates.quotientMap h' h).eq_generateFrom⟩
state_before: case intro.intro.intro
α : Type u
t : TopologicalSpace α
X : Type u_1
inst✝² : TopologicalSpace X
Y : Type u_2
inst✝¹ : TopologicalSpace Y
π : X → Y
inst✝ : SecondCountableTopology X
h' : QuotientMap π
h : IsOpenMap π
V : Set (Set X)
V_countable : Set.Countable V
V_generates : IsTopologicalBasis V
⊢ ∃ b, Set.Countable b ∧ inst✝¹ = generateFrom b
Theorem: Fin.le_zero_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Nat.eq_zero_of_le_zero h]
state_before: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
h : k ≤ 0
⊢ ↑k = ↑0

tactic: rfl
state_before: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
h : k ≤ 0
⊢ 0 = ↑0

tactic: rintro rfl
state_before: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
⊢ k = 0 → k ≤ 0

tactic: exact le_refl _
state_before: n✝ m n : ℕ
inst✝ : NeZero n
⊢ 0 ≤ 0
Theorem: AlgebraicGeometry.PresheafedSpace.stalkMap.congr
File: Mathlib/AlgebraicGeometry/Stalks.lean

tactic: rw [h₂]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α β : X ⟶ Y
h₁ : α = β
x x' : ↑↑X
h₂ : x = x'
⊢ stalk X x = stalk X x'

tactic: rw [h₁, h₂]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α β : X ⟶ Y
h₁ : α = β
x x' : ↑↑X
h₂ : x = x'
⊢ stalk Y ((CategoryTheory.forget TopCat).map α.base x) = stalk Y ((CategoryTheory.forget TopCat).map β.base x')

tactic: subst h₁
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α β : X ⟶ Y
h₁ : α = β
x x' : ↑↑X
h₂ : x = x'
U : Opens ↑↑Y
hx : (CategoryTheory.forget TopCat).map α.base x ∈ U
⊢ germ Y.presheaf { val := (CategoryTheory.forget TopCat).map α.base x, property := hx } ≫
      stalkMap α x ≫ eqToHom (_ : stalk X x = stalk X x') =
    germ Y.presheaf { val := (CategoryTheory.forget TopCat).map α.base x, property := hx } ≫
      eqToHom
          (_ :
            stalk Y ((CategoryTheory.forget TopCat).map α.base x) =
              stalk Y ((CategoryTheory.forget TopCat).map β.base x')) ≫
        stalkMap β x'

tactic: subst h₂
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
x x' : ↑↑X
h₂ : x = x'
U : Opens ↑↑Y
hx : (CategoryTheory.forget TopCat).map α.base x ∈ U
⊢ germ Y.presheaf { val := (CategoryTheory.forget TopCat).map α.base x, property := hx } ≫
      stalkMap α x ≫ eqToHom (_ : stalk X x = stalk X x') =
    germ Y.presheaf { val := (CategoryTheory.forget TopCat).map α.base x, property := hx } ≫
      eqToHom
          (_ :
            stalk Y ((CategoryTheory.forget TopCat).map α.base x) =
              stalk Y ((CategoryTheory.forget TopCat).map α.base x')) ≫
        stalkMap α x'

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
x : ↑↑X
U : Opens ↑↑Y
hx : (CategoryTheory.forget TopCat).map α.base x ∈ U
⊢ germ Y.presheaf { val := (CategoryTheory.forget TopCat).map α.base x, property := hx } ≫
      stalkMap α x ≫ eqToHom (_ : stalk X x = stalk X x) =
    germ Y.presheaf { val := (CategoryTheory.forget TopCat).map α.base x, property := hx } ≫
      eqToHom
          (_ :
            stalk Y ((CategoryTheory.forget TopCat).map α.base x) =
              stalk Y ((CategoryTheory.forget TopCat).map α.base x)) ≫
        stalkMap α x
Theorem: Finsupp.total_unique
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [← total_single, ← unique_single l]
state_before: α : Type u_1
M : Type u_3
N : Type ?u.323475
P : Type ?u.323478
R : Type u_2
S : Type ?u.323484
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
α' : Type ?u.323576
M' : Type ?u.323579
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M
inst✝² : Module R M'
inst✝¹ : Module R M
v✝ : α → M
v' : α' → M'
inst✝ : Unique α
l : α →₀ R
v : α → M
⊢ ↑(Finsupp.total α M R v) l = ↑l default • v default
Theorem: NNReal.pow_nat_rpow_nat_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← NNReal.coe_eq, coe_rpow, NNReal.coe_pow]
state_before: x : ℝ≥0
n : ℕ
hn : n ≠ 0
⊢ (x ^ n) ^ (↑n)⁻¹ = x

tactic: exact Real.pow_nat_rpow_nat_inv x.2 hn
state_before: x : ℝ≥0
n : ℕ
hn : n ≠ 0
⊢ (↑x ^ n) ^ (↑n)⁻¹ = ↑x
Theorem: CategoryTheory.Iso.homCongr_apply
File: Mathlib/CategoryTheory/Conj.lean

tactic: rfl
state_before: C : Type u
inst✝ : Category C
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X ⟶ Y
⊢ ↑(homCongr α β) f = α.inv ≫ f ≫ β.hom
Theorem: div_le_one_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rcases lt_trichotomy b 0 with (hb | rfl | hb)
state_before: ι : Type ?u.173722
α : Type u_1
β : Type ?u.173728
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ a / b ≤ 1 ↔ 0 < b ∧ a ≤ b ∨ b = 0 ∨ b < 0 ∧ b ≤ a

tactic: simp [hb, hb.not_lt, hb.ne, div_le_one_of_neg]
state_before: case inl
ι : Type ?u.173722
α : Type u_1
β : Type ?u.173728
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ a / b ≤ 1 ↔ 0 < b ∧ a ≤ b ∨ b = 0 ∨ b < 0 ∧ b ≤ a

tactic: simp [zero_le_one]
state_before: case inr.inl
ι : Type ?u.173722
α : Type u_1
β : Type ?u.173728
inst✝ : LinearOrderedField α
a c d : α
n : ℤ
⊢ a / 0 ≤ 1 ↔ 0 < 0 ∧ a ≤ 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 ≤ a

tactic: simp [hb, hb.not_lt, div_le_one, hb.ne.symm]
state_before: case inr.inr
ι : Type ?u.173722
α : Type u_1
β : Type ?u.173728
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : 0 < b
⊢ a / b ≤ 1 ↔ 0 < b ∧ a ≤ b ∨ b = 0 ∨ b < 0 ∧ b ≤ a
Theorem: ENNReal.toReal_add
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift a to ℝ≥0 using ha
state_before: α : Type ?u.789991
β : Type ?u.789994
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ ENNReal.toReal (a + b) = ENNReal.toReal a + ENNReal.toReal b

tactic: lift b to ℝ≥0 using hb
state_before: case intro
α : Type ?u.789991
β : Type ?u.789994
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ ENNReal.toReal (↑a + b) = ENNReal.toReal ↑a + ENNReal.toReal b

tactic: rfl
state_before: case intro.intro
α : Type ?u.789991
β : Type ?u.789994
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ ENNReal.toReal (↑a + ↑b) = ENNReal.toReal ↑a + ENNReal.toReal ↑b
Theorem: Mathlib.Meta.NormNum.isNat_ofScientific_of_false
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp [σh, Rat.ofScientific_false_def, h]
state_before: α : Type u_1
inst✝ : DivisionRing α
σα : OfScientific α
n✝¹ n✝ x✝ : ℕ
σh : OfScientific.ofScientific = fun m s e => ↑(Rat.ofScientific m s e)
h : x✝ = Nat.mul n✝¹ (10 ^ n✝)
⊢ OfScientific.ofScientific (↑n✝¹) false ↑n✝ = ↑x✝

tactic: norm_cast
state_before: α : Type u_1
inst✝ : DivisionRing α
σα : OfScientific α
n✝¹ n✝ x✝ : ℕ
σh : OfScientific.ofScientific = fun m s e => ↑(Rat.ofScientific m s e)
h : x✝ = Nat.mul n✝¹ (10 ^ n✝)
⊢ ↑(↑n✝¹ * 10 ^ n✝) = ↑n✝¹ * 10 ^ n✝
Theorem: nhdsWithin_pi_eq'
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [nhdsWithin, nhds_pi, Filter.pi, comap_inf, comap_iInf, pi_def, comap_principal, ←
  iInf_principal_finite hI, ← iInf_inf_eq]
state_before: α✝ : Type ?u.23519
β : Type ?u.23522
γ : Type ?u.23525
δ : Type ?u.23528
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
I : Set ι
hI : Set.Finite I
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ 𝓝[Set.pi I s] x = ⨅ (i : ι), comap (fun x => x i) (𝓝 (x i) ⊓ ⨅ (_ : i ∈ I), 𝓟 (s i))