tasksource/leandojo huggingface dataset:
Theorem: preperfect_iff_perfect_closure
File: Mathlib/Topology/Perfect.lean

tactic: constructor <;> intro h
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
⊢ Preperfect C ↔ Perfect (closure C)

tactic: intro x xC
state_before: case mpr
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
⊢ Preperfect C

tactic: have H : AccPt x (𝓟 (closure C)) := h.acc _ (subset_closure xC)
state_before: case mpr
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
⊢ AccPt x (𝓟 C)

tactic: rw [accPt_iff_frequently] at *
state_before: case mpr
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : AccPt x (𝓟 (closure C))
⊢ AccPt x (𝓟 C)

tactic: have : ∀ y, y ≠ x ∧ y ∈ closure C → ∃ᶠ z in 𝓝 y, z ≠ x ∧ z ∈ C := by
  rintro y ⟨hyx, yC⟩
  simp only [← mem_compl_singleton_iff, and_comm, ← frequently_nhdsWithin_iff,
    hyx.nhdsWithin_compl_singleton, ← mem_closure_iff_frequently]
  exact yC
state_before: case mpr
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ closure C
⊢ ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ C

tactic: rw [← frequently_frequently_nhds]
state_before: case mpr
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ closure C
this : ∀ (y : α), y ≠ x ∧ y ∈ closure C → ∃ᶠ (z : α) in 𝓝 y, z ≠ x ∧ z ∈ C
⊢ ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ C

tactic: exact H.mono this
state_before: case mpr
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ closure C
this : ∀ (y : α), y ≠ x ∧ y ∈ closure C → ∃ᶠ (z : α) in 𝓝 y, z ≠ x ∧ z ∈ C
⊢ ∃ᶠ (y : α) in 𝓝 x, ∃ᶠ (x_1 : α) in 𝓝 y, x_1 ≠ x ∧ x_1 ∈ C

tactic: exact h.perfect_closure
state_before: case mp
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Preperfect C
⊢ Perfect (closure C)

tactic: rintro y ⟨hyx, yC⟩
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ closure C
⊢ ∀ (y : α), y ≠ x ∧ y ∈ closure C → ∃ᶠ (z : α) in 𝓝 y, z ≠ x ∧ z ∈ C

tactic: simp only [← mem_compl_singleton_iff, and_comm, ← frequently_nhdsWithin_iff,
  hyx.nhdsWithin_compl_singleton, ← mem_closure_iff_frequently]
state_before: case intro
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ closure C
y : α
hyx : y ≠ x
yC : y ∈ closure C
⊢ ∃ᶠ (z : α) in 𝓝 y, z ≠ x ∧ z ∈ C

tactic: exact yC
state_before: case intro
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
h : Perfect (closure C)
x : α
xC : x ∈ C
H : ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ closure C
y : α
hyx : y ≠ x
yC : y ∈ closure C
⊢ y ∈ closure C
Theorem: ENNReal.lintegral_mul_le_one_of_lintegral_rpow_eq_one
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: simp only [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_norm : (∫⁻ (a : α), f a ^ p ∂μ) = 1
hg_norm : (∫⁻ (a : α), g a ^ q ∂μ) = 1
⊢ (∫⁻ (a : α), f a ^ p / ENNReal.ofReal p + g a ^ q / ENNReal.ofReal q ∂μ) = 1

tactic: rw [lintegral_add_left']
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_norm : (∫⁻ (a : α), f a ^ p ∂μ) = 1
hg_norm : (∫⁻ (a : α), g a ^ q ∂μ) = 1
⊢ (∫⁻ (a : α), f a ^ p * (ENNReal.ofReal p)⁻¹ + g a ^ q * (ENNReal.ofReal q)⁻¹ ∂μ) = 1

tactic: rw [lintegral_mul_const'' _ (hf.pow_const p), lintegral_mul_const', hf_norm, hg_norm, ←
  div_eq_mul_inv, ← div_eq_mul_inv, hpq.inv_add_inv_conj_ennreal]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_norm : (∫⁻ (a : α), f a ^ p ∂μ) = 1
hg_norm : (∫⁻ (a : α), g a ^ q ∂μ) = 1
⊢ ((∫⁻ (a : α), f a ^ p * (ENNReal.ofReal p)⁻¹ ∂μ) + ∫⁻ (a : α), g a ^ q * (ENNReal.ofReal q)⁻¹ ∂μ) = 1

tactic: simp [hpq.symm.pos]
state_before: case hr
α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_norm : (∫⁻ (a : α), f a ^ p ∂μ) = 1
hg_norm : (∫⁻ (a : α), g a ^ q ∂μ) = 1
⊢ (ENNReal.ofReal q)⁻¹ ≠ ⊤

tactic: exact (hf.pow_const _).mul_const _
state_before: case hf
α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_norm : (∫⁻ (a : α), f a ^ p ∂μ) = 1
hg_norm : (∫⁻ (a : α), g a ^ q ∂μ) = 1
⊢ AEMeasurable fun a => f a ^ p * (ENNReal.ofReal p)⁻¹
Theorem: Finset.filter_lt_le_eq_Ioc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.37672
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j ≤ b
⊢ filter (fun j => a < j ∧ j ≤ b) univ = Ioc a b

tactic: simp
state_before: case a
ι : Type ?u.37672
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a < j ∧ j ≤ b
a✝ : α
⊢ a✝ ∈ filter (fun j => a < j ∧ j ≤ b) univ ↔ a✝ ∈ Ioc a b
Theorem: Ordinal.cof_lsub_le_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← mk_uLift.{u, v}]
state_before: α : Type ?u.22098
r : α → α → Prop
ι : Type u
f : ι → Ordinal
⊢ cof (lsub f) ≤ Cardinal.lift (#ι)

tactic: convert cof_lsub_le.{max u v} fun i : ULift.{v, u} ι => f i.down
state_before: α : Type ?u.22098
r : α → α → Prop
ι : Type u
f : ι → Ordinal
⊢ cof (lsub f) ≤ (#ULift ι)

tactic: exact
  lsub_eq_of_range_eq.{u, max u v, max u v}
    (Set.ext fun x => ⟨fun ⟨i, hi⟩ => ⟨ULift.up.{v, u} i, hi⟩, fun ⟨i, hi⟩ => ⟨_, hi⟩⟩)
state_before: case h.e'_3.h.e'_1
α : Type ?u.22098
r : α → α → Prop
ι : Type u
f : ι → Ordinal
⊢ lsub f = lsub fun i => f i.down
Theorem: DMatrix.map_add
File: Mathlib/Data/Matrix/DMatrix.lean

tactic: ext
state_before: l : Type ?u.19439
m : Type u_1
n : Type u_2
o : Type ?u.19448
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddMonoid (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddMonoid (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
⊢ (map (M + N) fun i j => ↑f) = (map M fun i j => ↑f) + map N fun i j => ↑f

tactic: simp
state_before: case a
l : Type ?u.19439
m : Type u_1
n : Type u_2
o : Type ?u.19448
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
α : m → n → Type v
inst✝¹ : (i : m) → (j : n) → AddMonoid (α i j)
β : m → n → Type w
inst✝ : (i : m) → (j : n) → AddMonoid (β i j)
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j →+ β i j
M N : DMatrix m n α
i✝ : m
j✝ : n
⊢ map (M + N) (fun i j => ↑f) i✝ j✝ = ((map M fun i j => ↑f) + map N fun i j => ↑f) i✝ j✝
Theorem: edist_vsub_vsub_le
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

tactic: simp only [edist_nndist]
state_before: α : Type ?u.29026
V : Type u_1
P : Type u_2
W : Type ?u.29035
Q : Type ?u.29038
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ edist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ edist p₁ p₃ + edist p₂ p₄

tactic: norm_cast
state_before: α : Type ?u.29026
V : Type u_1
P : Type u_2
W : Type ?u.29035
Q : Type ?u.29038
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ ↑(nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄)) ≤ ↑(nndist p₁ p₃) + ↑(nndist p₂ p₄)

tactic: apply dist_vsub_vsub_le
state_before: α : Type ?u.29026
V : Type u_1
P : Type u_2
W : Type ?u.29035
Q : Type ?u.29038
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ nndist p₁ p₃ + nndist p₂ p₄
Theorem: Denumerable.list_ofNat_succ
File: Mathlib/Logic/Equiv/List.lean

tactic: cases' e : unpair v with v₁ v₂
state_before: α : Type u_1
β : Type ?u.39088
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v : ℕ
⊢ decodeList (succ v) = some (ofNat α (unpair v).fst :: ofNat (List α) (unpair v).snd)

tactic: simp [decodeList, e]
state_before: case mk
α : Type u_1
β : Type ?u.39088
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ decodeList (succ v) = some (ofNat α (v₁, v₂).fst :: ofNat (List α) (v₁, v₂).snd)

tactic: rw [show decodeList v₂ = decode (α := List α) v₂ from rfl, decode_eq_ofNat, Option.seq_some,
  Option.some.injEq]
state_before: case mk
α : Type u_1
β : Type ?u.39088
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ (Seq.seq (some fun x => ofNat α v₁ :: x) fun x => decodeList v₂) = some (ofNat α v₁ :: ofNat (List α) v₂)
Theorem: Function.iterate_mul
File: Mathlib/Logic/Function/Iterate.lean

tactic: simp only [Nat.mul_zero, iterate_zero]
state_before: α : Type u
β : Type v
f : α → α
m : ℕ
⊢ f^[m * 0] = f^[m]^[0]

tactic: simp only [Nat.mul_succ, Nat.mul_one, iterate_one, iterate_add, iterate_mul m n]
state_before: α : Type u
β : Type v
f : α → α
m n : ℕ
⊢ f^[m * (n + 1)] = f^[m]^[n + 1]
Theorem: CHSH_id
File: Mathlib/Algebra/Star/CHSH.lean

tactic: rw [← sub_eq_zero]
state_before: R : Type u
inst✝ : CommRing R
A₀ A₁ B₀ B₁ : R
A₀_inv : A₀ ^ 2 = 1
A₁_inv : A₁ ^ 2 = 1
B₀_inv : B₀ ^ 2 = 1
B₁_inv : B₁ ^ 2 = 1
⊢ (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) =
    4 * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁)

tactic: repeat'
  ring_nf
  simp only [A₁_inv, B₁_inv, sub_eq_add_neg, add_mul, mul_add, sub_mul, mul_sub, add_assoc,
    neg_add, neg_sub, sub_add, sub_sub, neg_mul, ← sq, A₀_inv, B₀_inv, ← sq, ← mul_assoc, one_mul,
    mul_one, add_right_neg, add_zero, sub_eq_add_neg, A₀_inv, mul_one, add_right_neg,
    MulZeroClass.zero_mul]
state_before: R : Type u
inst✝ : CommRing R
A₀ A₁ B₀ B₁ : R
A₀_inv : A₀ ^ 2 = 1
A₁_inv : A₁ ^ 2 = 1
B₀_inv : B₀ ^ 2 = 1
B₁_inv : B₁ ^ 2 = 1
⊢ (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) -
      4 * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) =
    0

tactic: ring_nf
state_before: R : Type u
inst✝ : CommRing R
A₀ A₁ B₀ B₁ : R
A₀_inv : A₀ ^ 2 = 1
A₁_inv : A₁ ^ 2 = 1
B₀_inv : B₀ ^ 2 = 1
B₁_inv : B₁ ^ 2 = 1
⊢ -4 + (B₀ * B₁ * 2 + (1 ^ 2 + (1 ^ 2 + (-(B₀ * B₁ * 2) + (1 ^ 2 + 1 ^ 2))))) = 0
Theorem: uniqueDiffOn_Icc
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp only [interior_Icc, nonempty_Ioo, hab]
state_before: 𝕜 : Type ?u.179894
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.179900
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.179995
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.180085
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a b : ℝ
hab : a < b
⊢ Set.Nonempty (interior (Icc a b))
Theorem: Polynomial.pow_rootMultiplicity_dvd
File: Mathlib/Data/Polynomial/Div.lean

tactic: simp [h]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
h : p = 0
⊢ (X - ↑C a) ^ rootMultiplicity a p ∣ p

tactic: rw [rootMultiplicity_eq_multiplicity, dif_neg h]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
h : ¬p = 0
⊢ (X - ↑C a) ^ rootMultiplicity a p ∣ p

tactic: exact multiplicity.pow_multiplicity_dvd _
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
h : ¬p = 0
⊢ (X - ↑C a) ^ Part.get (multiplicity (X - ↑C a) p) (_ : multiplicity.Finite (X - ↑C a) p) ∣ p
Theorem: MeasureTheory.summable_measure_toReal
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: apply ENNReal.summable_toReal
state_before: α : Type u_1
β : Type ?u.645610
γ : Type ?u.645613
δ : Type ?u.645616
ι : Type ?u.645619
R : Type ?u.645622
R' : Type ?u.645625
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ Summable fun x => ENNReal.toReal (↑↑μ (f x))

tactic: rw [← MeasureTheory.measure_iUnion hf₂ hf₁]
state_before: case hsum
α : Type u_1
β : Type ?u.645610
γ : Type ?u.645613
δ : Type ?u.645616
ι : Type ?u.645619
R : Type ?u.645622
R' : Type ?u.645625
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ (∑' (x : ℕ), ↑↑μ (f x)) ≠ ⊤

tactic: exact ne_of_lt (measure_lt_top _ _)
state_before: case hsum
α : Type u_1
β : Type ?u.645610
γ : Type ?u.645613
δ : Type ?u.645616
ι : Type ?u.645619
R : Type ?u.645622
R' : Type ?u.645625
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ ↑↑μ (⋃ (i : ℕ), f i) ≠ ⊤
Theorem: Real.arctan_eq_of_tan_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [tan_arctan, h]
state_before: x y : ℝ
h : tan x = y
hx : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ tan (arctan y) = tan x
Theorem: MeasureTheory.lintegral_add_compl
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← lintegral_add_measure, Measure.restrict_add_restrict_compl hA]
state_before: α : Type u_1
β : Type ?u.1028581
γ : Type ?u.1028584
δ : Type ?u.1028587
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
A : Set α
hA : MeasurableSet A
⊢ ((∫⁻ (x : α) in A, f x ∂μ) + ∫⁻ (x : α) in Aᶜ, f x ∂μ) = ∫⁻ (x : α), f x ∂μ
Theorem: Nat.cast_div_charZero
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: R : Type ?u.1348
inst✝³ : AddMonoidWithOne R
inst✝² : CharZero R
k : Type u_1
inst✝¹ : DivisionSemiring k
inst✝ : CharZero k
m n : ℕ
n_dvd : n ∣ m
⊢ ↑(m / n) = ↑m / ↑n

tactic: simp
state_before: case inl
R : Type ?u.1348
inst✝³ : AddMonoidWithOne R
inst✝² : CharZero R
k : Type u_1
inst✝¹ : DivisionSemiring k
inst✝ : CharZero k
m : ℕ
n_dvd : 0 ∣ m
⊢ ↑(m / 0) = ↑m / ↑0

tactic: exact cast_div n_dvd (cast_ne_zero.2 hn)
state_before: case inr
R : Type ?u.1348
inst✝³ : AddMonoidWithOne R
inst✝² : CharZero R
k : Type u_1
inst✝¹ : DivisionSemiring k
inst✝ : CharZero k
m n : ℕ
n_dvd : n ∣ m
hn : n ≠ 0
⊢ ↑(m / n) = ↑m / ↑n
Theorem: PrimeMultiset.coePNat_prime
File: Mathlib/Data/PNat/Factors.lean

tactic: rcases Multiset.mem_map.mp h with ⟨⟨_, hp'⟩, ⟨_, h_eq⟩⟩
state_before: v : PrimeMultiset
p : ℕ+
h : p ∈ toPNatMultiset v
⊢ PNat.Prime p

tactic: exact h_eq ▸ hp'
state_before: case intro.mk.intro
v : PrimeMultiset
p : ℕ+
h : p ∈ toPNatMultiset v
val✝ : ℕ
hp' : Nat.Prime val✝
left✝ : { val := val✝, property := hp' } ∈ v
h_eq : Coe.coe { val := val✝, property := hp' } = p
⊢ PNat.Prime p
Theorem: Fintype.prod_subtype_mul_prod_subtype
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: let s := { x | p x }.toFinset
state_before: ι : Type ?u.881033
β✝ : Type u
α✝ : Type v
γ : Type w
s s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : CommMonoid β
p : α → Prop
f : α → β
inst✝ : DecidablePred p
⊢ (∏ i : { x // p x }, f ↑i) * ∏ i : { x // ¬p x }, f ↑i = ∏ i : α, f i

tactic: rw [← Finset.prod_subtype s, ← Finset.prod_subtype (sᶜ)]
state_before: ι : Type ?u.881033
β✝ : Type u
α✝ : Type v
γ : Type w
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : CommMonoid β
p : α → Prop
f : α → β
inst✝ : DecidablePred p
s : Finset α := Set.toFinset {x | p x}
⊢ (∏ i : { x // p x }, f ↑i) * ∏ i : { x // ¬p x }, f ↑i = ∏ i : α, f i

tactic: exact Finset.prod_mul_prod_compl _ _
state_before: ι : Type ?u.881033
β✝ : Type u
α✝ : Type v
γ : Type w
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : CommMonoid β
p : α → Prop
f : α → β
inst✝ : DecidablePred p
s : Finset α := Set.toFinset {x | p x}
⊢ (∏ a in s, f a) * ∏ a in sᶜ, f a = ∏ i : α, f i

tactic: simp
state_before: case h
ι : Type ?u.881033
β✝ : Type u
α✝ : Type v
γ : Type w
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : CommMonoid β
p : α → Prop
f : α → β
inst✝ : DecidablePred p
s : Finset α := Set.toFinset {x | p x}
⊢ ∀ (x : α), x ∈ sᶜ ↔ ¬p x

tactic: simp
state_before: case h
ι : Type ?u.881033
β✝ : Type u
α✝ : Type v
γ : Type w
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : CommMonoid β
p : α → Prop
f : α → β
inst✝ : DecidablePred p
s : Finset α := Set.toFinset {x | p x}
⊢ ∀ (x : α), x ∈ s ↔ p x
Theorem: iSup_eq_top
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [← sSup_range, sSup_eq_top, Set.exists_range_iff]
state_before: α : Type u_1
β : Type ?u.187342
β₂ : Type ?u.187345
γ : Type ?u.187348
ι : Sort u_2
ι' : Sort ?u.187354
κ : ι → Sort ?u.187359
κ' : ι' → Sort ?u.187364
inst✝ : CompleteLinearOrder α
f : ι → α
⊢ iSup f = ⊤ ↔ ∀ (b : α), b < ⊤ → ∃ i, b < f i
Theorem: Filter.Tendsto.atBot_mul_const'
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simp only [← tendsto_neg_atTop_iff, ← neg_mul] at hf⊢
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedRing R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atBot
⊢ Tendsto (fun x => f x * r) l atBot

tactic: exact hf.atTop_mul_const' hr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedRing R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto (fun x => -f x) l atTop
⊢ Tendsto (fun x => -f x * r) l atTop
Theorem: Cardinal.lift_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_aleph0.{u,v}, lift_lt]
state_before: α β : Type u
c : Cardinal
⊢ lift c < ℵ₀ ↔ c < ℵ₀
Theorem: Set.Finite.toFinset_inter
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : Set.Finite s
ht✝ : Set.Finite t
inst✝ : DecidableEq α
hs : Set.Finite s
ht : Set.Finite t
h : Set.Finite (s ∩ t)
⊢ Finite.toFinset h = Finite.toFinset hs ∩ Finite.toFinset ht

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : Set.Finite s
ht✝ : Set.Finite t
inst✝ : DecidableEq α
hs : Set.Finite s
ht : Set.Finite t
h : Set.Finite (s ∩ t)
a✝ : α
⊢ a✝ ∈ Finite.toFinset h ↔ a✝ ∈ Finite.toFinset hs ∩ Finite.toFinset ht
Theorem: PadicInt.appr_mono
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: apply monotone_nat_of_le_succ
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ Monotone (appr x)

tactic: intro n
state_before: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ∀ (n : ℕ), appr x n ≤ appr x (n + 1)

tactic: dsimp [appr]
state_before: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
⊢ appr x n ≤ appr x (n + 1)

tactic: split_ifs
state_before: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
⊢ appr x n ≤
    if hy : x - ↑(appr x (n + 0)) = 0 then appr x (n + 0)
    else
      appr x (n + 0) +
        p ^ (n + 0) *
          ZMod.val (↑toZMod (↑(unitCoeff hy) * ↑p ^ Int.natAbs (valuation (x - ↑(appr x (n + 0))) - ↑(n + 0))))

tactic: apply Nat.le_add_right
state_before: case hf.inr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
h✝ : ¬x - ↑(appr x (n + 0)) = 0
⊢ appr x n ≤
    appr x (n + 0) +
      p ^ (n + 0) *
        ZMod.val
          (↑toZMod
            (↑(unitCoeff (_ : ¬x - ↑(appr x (n + 0)) = 0)) *
              ↑p ^ Int.natAbs (valuation (x - ↑(appr x (n + 0))) - ↑(n + 0))))

tactic: rfl
state_before: case hf.inl
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
h✝ : x - ↑(appr x (n + 0)) = 0
⊢ appr x n ≤ appr x (n + 0)
Theorem: Set.Nonempty.smul_zero
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simpa [mem_smul] using hs
state_before: F : Type ?u.80091
α : Type u_1
β : Type u_2
γ : Type ?u.80100
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
s : Set α
t : Set β
hs : Set.Nonempty s
⊢ 0 ⊆ s • 0
Theorem: CategoryTheory.Limits.biprod.symmetry'
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: aesop_cat
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
P✝ Q✝ : C
inst✝ : HasBinaryBiproducts C
P Q : C
⊢ lift snd fst ≫ lift snd fst = 𝟙 (P ⊞ Q)
Theorem: Ordinal.mod_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [div_add_mod]
state_before: α : Type ?u.259815
β : Type ?u.259818
γ : Type ?u.259821
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : b ≠ 0
⊢ b * (a / b) + a % b < b * (a / b) + b

tactic: exact lt_mul_div_add a h
state_before: α : Type ?u.259815
β : Type ?u.259818
γ : Type ?u.259821
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : b ≠ 0
⊢ a < b * (a / b) + b
Theorem: OrderIso.comap_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [atTop, ← e.surjective.iInf_comp]
state_before: ι : Type ?u.49076
ι' : Type ?u.49079
α : Type u_1
β : Type u_2
γ : Type ?u.49088
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
⊢ comap (↑e) atTop = atTop
Theorem: Coheyting.boundary_sup_le
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, inf_sup_right]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ (a ⊔ b) ≤ ∂ a ⊔ ∂ b

tactic: exact
  sup_le_sup (inf_le_inf_left _ <| hnot_anti le_sup_left)
    (inf_le_inf_left _ <| hnot_anti le_sup_right)
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ a ⊓ ￢(a ⊔ b) ⊔ b ⊓ ￢(a ⊔ b) ≤ ∂ a ⊔ ∂ b
Theorem: FreeMonoid.countp_of
File: Mathlib/Algebra/FreeMonoid/Count.lean

tactic: rw [countp_of', ofAdd_zero]
state_before: α : Type u_1
p : α → Prop
inst✝ : DecidablePred p
x : α
⊢ ↑(countp p) (of x) = if p x then ↑Multiplicative.ofAdd 1 else 1
Theorem: BoundedContinuousFunction.abs_self_eq_nnrealPart_add_nnrealPart_neg
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: funext x
state_before: F : Type ?u.1620901
α : Type u
β : Type v
γ : Type w
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
⊢ abs ∘ ↑f = toReal ∘ ↑(nnrealPart f) + toReal ∘ ↑(nnrealPart (-f))

tactic: dsimp
state_before: case h
F : Type ?u.1620901
α : Type u
β : Type v
γ : Type w
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
x : α
⊢ (abs ∘ ↑f) x = (toReal ∘ ↑(nnrealPart f) + toReal ∘ ↑(nnrealPart (-f))) x

tactic: simp only [max_zero_add_max_neg_zero_eq_abs_self]
state_before: case h
F : Type ?u.1620901
α : Type u
β : Type v
γ : Type w
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
x : α
⊢ abs (↑f x) = max (↑f x) 0 + max (-↑f x) 0
Theorem: Int.nnnorm_coe_units
File: Mathlib/Analysis/NormedSpace/Int.lean

tactic: obtain rfl | rfl := units_eq_one_or e <;>
  simp only [Units.coe_neg_one, Units.val_one, nnnorm_neg, nnnorm_one]
state_before: e : ℤˣ
⊢ ‖↑e‖₊ = 1
Theorem: QuadraticForm.associated_left_inverse
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [associated_toQuadraticForm, h.eq x y, ← two_mul, ← mul_assoc, invOf_mul_self,
  one_mul]
state_before: S : Type u_3
R : Type u_1
R₁ : Type ?u.423118
M : Type u_2
inst✝⁷ : Ring R
inst✝⁶ : CommRing R₁
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : Module R₁ M
inst✝² : CommSemiring S
inst✝¹ : Algebra S R
inst✝ : Invertible 2
B₁ : BilinForm R M
Q : QuadraticForm R M
h : BilinForm.IsSymm B₁
x y : M
⊢ bilin (↑(associatedHom S) (toQuadraticForm B₁)) x y = bilin B₁ x y