tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.OuterMeasure.top_apply'
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.126091
R : Type ?u.126094
R' : Type ?u.126097
ms : Set (OuterMeasure α)
m : OuterMeasure α
s : Set α
h : s = ∅
⊢ ↑⊤ s = ⨅ (_ : s = ∅), 0

tactic: simp [h, h.ne_empty]
state_before: α : Type u_1
β : Type ?u.126091
R : Type ?u.126094
R' : Type ?u.126097
ms : Set (OuterMeasure α)
m : OuterMeasure α
s : Set α
h : Set.Nonempty s
⊢ ↑⊤ s = ⨅ (_ : s = ∅), 0
Theorem: LinearMap.dualMap_surjective_of_injective
File: Mathlib/LinearAlgebra/Dual.lean

tactic: intro φ
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
⊢ Function.Surjective ↑(dualMap f)

tactic: let f' := LinearEquiv.ofInjective f hf
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
φ : Dual K V₁
⊢ ∃ a, ↑(dualMap f) a = φ

tactic: use Subspace.dualLift (range f) (f'.symm.dualMap φ)
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
φ : Dual K V₁
f' : V₁ ≃ₗ[K] { x // x ∈ range f } := LinearEquiv.ofInjective f hf
⊢ ∃ a, ↑(dualMap f) a = φ

tactic: ext x
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
φ : Dual K V₁
f' : V₁ ≃ₗ[K] { x // x ∈ range f } := LinearEquiv.ofInjective f hf
⊢ ↑(dualMap f) (↑(Subspace.dualLift (range f)) (↑(LinearEquiv.dualMap (LinearEquiv.symm f')) φ)) = φ

tactic: rw [LinearMap.dualMap_apply, Subspace.dualLift_of_mem (mem_range_self f x),
  LinearEquiv.dualMap_apply]
state_before: case h
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
φ : Dual K V₁
f' : V₁ ≃ₗ[K] { x // x ∈ range f } := LinearEquiv.ofInjective f hf
x : V₁
⊢ ↑(↑(dualMap f) (↑(Subspace.dualLift (range f)) (↑(LinearEquiv.dualMap (LinearEquiv.symm f')) φ))) x = ↑φ x

tactic: congr 1
state_before: case h
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
φ : Dual K V₁
f' : V₁ ≃ₗ[K] { x // x ∈ range f } := LinearEquiv.ofInjective f hf
x : V₁
⊢ ↑φ (↑(LinearEquiv.symm f') { val := ↑f x, property := (_ : ↑f x ∈ range f) }) = ↑φ x

tactic: exact LinearEquiv.symm_apply_apply f' x
state_before: case h.h.e_6.h
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
hf : Function.Injective ↑f
φ : Dual K V₁
f' : V₁ ≃ₗ[K] { x // x ∈ range f } := LinearEquiv.ofInjective f hf
x : V₁
⊢ ↑(LinearEquiv.symm f') { val := ↑f x, property := (_ : ↑f x ∈ range f) } = x
Theorem: Matrix.updateColumn_submatrix_equiv
File: Mathlib/Data/Matrix/Basic.lean

tactic: simpa only [← transpose_submatrix, updateRow_transpose] using
  congr_arg transpose (updateRow_submatrix_equiv Aᵀ j c f e)
state_before: l : Type u_4
m : Type u_3
n : Type u_2
o : Type u_1
m' : o → Type ?u.1238605
n' : o → Type ?u.1238610
R : Type ?u.1238613
S : Type ?u.1238616
α : Type v
β : Type w
γ : Type ?u.1238623
M : Matrix m n α
i : m
j✝ : n
b : n → α
c✝ : m → α
inst✝¹ : DecidableEq o
inst✝ : DecidableEq n
A : Matrix m n α
j : o
c : l → α
e : l ≃ m
f : o ≃ n
⊢ updateColumn (submatrix A ↑e ↑f) j c = submatrix (updateColumn A (↑f j) fun i => c (↑e.symm i)) ↑e ↑f
Theorem: Finset.Ioc_erase_right
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp [← coe_inj]
state_before: ι : Type ?u.85417
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ erase (Ioc a b) b = Ioo a b
Theorem: nhdsWithin_eq_nhdsWithin'
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin_restrict' t hs, nhdsWithin_restrict' u hs, h₂]
state_before: α : Type u_1
β : Type ?u.12030
γ : Type ?u.12033
δ : Type ?u.12036
inst✝ : TopologicalSpace α
a : α
s t u : Set α
hs : s ∈ 𝓝 a
h₂ : t ∩ s = u ∩ s
⊢ 𝓝[t] a = 𝓝[u] a
Theorem: List.range'_append
File: Std/Data/List/Lemmas.lean

tactic: simpa [range', Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
  using range'_append (s + step) m n step
state_before: s m n step : Nat
⊢ range' s (m + 1) step ++ range' (s + step * (m + 1)) n step = range' s (n + (m + 1)) step
Theorem: Nat.minFac_le_div
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [h0, mul_zero]
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
h0 : n = minFac n * 0
⊢ ¬0 < n

tactic: exact by decide
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
h0 : n = minFac n * 0
⊢ ¬0 < 0

tactic: decide
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
h0 : n = minFac n * 0
⊢ ¬0 < 0

tactic: rw [mul_one] at h1
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
h1 : n = minFac n * 1
⊢ minFac n ≤ n / minFac n

tactic: rw [prime_def_minFac, not_and_or, ← h1, eq_self_iff_true, _root_.not_true, or_false_iff,
  not_le] at np
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
h1 : n = minFac n
⊢ minFac n ≤ n / minFac n

tactic: rw [le_antisymm (le_of_lt_succ np) (succ_le_of_lt pos), minFac_one, Nat.div_one]
state_before: n : ℕ
pos : 0 < n
np : n < 2
h1 : n = minFac n
⊢ minFac n ≤ n / minFac n

tactic: conv_rhs =>
  congr
  rw [hx]
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = minFac n * (x + 2)
⊢ minFac n ≤ n / minFac n

tactic: rw [Nat.mul_div_cancel_left _ (minFac_pos _)]
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = minFac n * (x + 2)
⊢ minFac n ≤ minFac n * (x + 2) / minFac n

tactic: exact minFac_le_of_dvd (le_add_left 2 x) ⟨minFac n, by rwa [mul_comm]⟩
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = minFac n * (x + 2)
⊢ minFac n ≤ x + 2

tactic: rwa [mul_comm]
state_before: n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = minFac n * (x + 2)
⊢ n = (x + 2) * minFac n
Theorem: PrimeSpectrum.comap_inducing_of_surjective
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simp_rw [topologicalSpace_eq_iff, ← isClosed_compl_iff,
  ← @isClosed_compl_iff (PrimeSpectrum S)
    ((TopologicalSpace.induced (comap f) zariskiTopology)), isClosed_induced_iff,
  isClosed_iff_zeroLocus]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.259728
inst✝ : CommRing S'
f : R →+* S
hf : Surjective ↑f
⊢ zariskiTopology = TopologicalSpace.induced (↑(comap f)) zariskiTopology

tactic: refine' fun s =>
  ⟨fun ⟨F, hF⟩ =>
    ⟨zeroLocus (f ⁻¹' F), ⟨f ⁻¹' F, rfl⟩, by
      rw [preimage_comap_zeroLocus, Function.Surjective.image_preimage hf, hF]⟩,
    _⟩
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.259728
inst✝ : CommRing S'
f : R →+* S
hf : Surjective ↑f
⊢ ∀ (s : Set (PrimeSpectrum S)), (∃ s_1, sᶜ = zeroLocus s_1) ↔ ∃ t, (∃ s, t = zeroLocus s) ∧ ↑(comap f) ⁻¹' t = sᶜ

tactic: rintro ⟨-, ⟨F, rfl⟩, hF⟩
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.259728
inst✝ : CommRing S'
f : R →+* S
hf : Surjective ↑f
s : Set (PrimeSpectrum S)
⊢ (∃ t, (∃ s, t = zeroLocus s) ∧ ↑(comap f) ⁻¹' t = sᶜ) → ∃ s_1, sᶜ = zeroLocus s_1

tactic: exact ⟨f '' F, hF.symm.trans (preimage_comap_zeroLocus f F)⟩
state_before: case intro.intro.intro
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.259728
inst✝ : CommRing S'
f : R →+* S
hf : Surjective ↑f
s : Set (PrimeSpectrum S)
F : Set R
hF : ↑(comap f) ⁻¹' zeroLocus F = sᶜ
⊢ ∃ s_1, sᶜ = zeroLocus s_1

tactic: rw [preimage_comap_zeroLocus, Function.Surjective.image_preimage hf, hF]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.259728
inst✝ : CommRing S'
f : R →+* S
hf : Surjective ↑f
s : Set (PrimeSpectrum S)
x✝ : ∃ s_1, sᶜ = zeroLocus s_1
F : Set S
hF : sᶜ = zeroLocus F
⊢ ↑(comap f) ⁻¹' zeroLocus (↑f ⁻¹' F) = sᶜ
Theorem: Matrix.submatrix_cons_row
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix m' n' α
i : m'
row : Fin m → m'
col : o' → n'
⊢ submatrix A (vecCons i row) col = vecCons (fun j => A i (col j)) (submatrix A row col)

tactic: refine' Fin.cases _ _ i <;> simp [submatrix]
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix m' n' α
i✝ : m'
row : Fin m → m'
col : o' → n'
i : Fin (Nat.succ m)
j : o'
⊢ submatrix A (vecCons i✝ row) col i j = vecCons (fun j => A i✝ (col j)) (submatrix A row col) i j
Theorem: BilinForm.finrank_add_finrank_orthogonal
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [← toLin_restrict_ker_eq_inf_orthogonal _ _ b₁, ←
  toLin_restrict_range_dualCoannihilator_eq_orthogonal _ _, Submodule.finrank_map_subtype_eq]
state_before: R : Type ?u.1617651
M : Type ?u.1617654
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type ?u.1617690
M₁ : Type ?u.1617693
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type ?u.1618302
M₂ : Type ?u.1618305
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type ?u.1618492
M₃ : Type ?u.1618495
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_2
K : Type u_1
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1620300
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Subspace K V
b₁ : IsRefl B
⊢ finrank K { x // x ∈ W } + finrank K { x // x ∈ orthogonal B W } =
    finrank K V + finrank K { x // x ∈ W ⊓ orthogonal B ⊤ }

tactic: conv_rhs =>
  rw [← @Subspace.finrank_add_finrank_dualCoannihilator_eq K V _ _ _ _
      (LinearMap.range (B.toLin.domRestrict W)),
    add_comm, ← add_assoc, add_comm (finrank K (LinearMap.ker (B.toLin.domRestrict W))),
    LinearMap.finrank_range_add_finrank_ker]
state_before: R : Type ?u.1617651
M : Type ?u.1617654
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type ?u.1617690
M₁ : Type ?u.1617693
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type ?u.1618302
M₂ : Type ?u.1618305
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type ?u.1618492
M₃ : Type ?u.1618495
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_2
K : Type u_1
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1620300
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
inst✝ : FiniteDimensional K V
B : BilinForm K V
W : Subspace K V
b₁ : IsRefl B
⊢ finrank K { x // x ∈ W } +
      finrank K { x // x ∈ Submodule.dualCoannihilator (LinearMap.range (LinearMap.domRestrict (↑toLin B) W)) } =
    finrank K V + finrank K { x // x ∈ LinearMap.ker (LinearMap.domRestrict (↑toLin B) W) }
Theorem: Ideal.span_singleton_mul_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: unfold span
state_before: R : Type u
ι : Type ?u.223899
inst✝ : CommSemiring R
I J K L : Ideal R
r s : R
⊢ span {r} * span {s} = span {r * s}

tactic: rw [Submodule.span_mul_span, Set.singleton_mul_singleton]
state_before: R : Type u
ι : Type ?u.223899
inst✝ : CommSemiring R
I J K L : Ideal R
r s : R
⊢ Submodule.span R {r} * Submodule.span R {s} = Submodule.span R {r * s}
Theorem: MvPolynomial.rename_injective
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: have :
  (rename f : MvPolynomial σ R → MvPolynomial τ R) = Finsupp.mapDomain (Finsupp.mapDomain f) :=
  funext (rename_eq f)
state_before: σ : Type u_1
τ : Type u_2
α : Type ?u.263211
R : Type u_3
S : Type ?u.263217
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
⊢ Injective ↑(rename f)

tactic: rw [this]
state_before: σ : Type u_1
τ : Type u_2
α : Type ?u.263211
R : Type u_3
S : Type ?u.263217
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
this : ↑(rename f) = Finsupp.mapDomain (Finsupp.mapDomain f)
⊢ Injective ↑(rename f)

tactic: exact Finsupp.mapDomain_injective (Finsupp.mapDomain_injective hf)
state_before: σ : Type u_1
τ : Type u_2
α : Type ?u.263211
R : Type u_3
S : Type ?u.263217
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
this : ↑(rename f) = Finsupp.mapDomain (Finsupp.mapDomain f)
⊢ Injective (Finsupp.mapDomain (Finsupp.mapDomain f))
Theorem: ZMod.valMinAbs_zero
File: Mathlib/Data/ZMod/Basic.lean

tactic: simp only [valMinAbs_def_zero]
state_before: ⊢ valMinAbs 0 = 0

tactic: simp only [valMinAbs_def_pos, if_true, Int.ofNat_zero, zero_le, val_zero]
state_before: n : ℕ
⊢ valMinAbs 0 = 0
Theorem: Associates.factors_le
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: have : a.factors.prod ≤ b.factors.prod := prod_mono h
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
h : factors a ≤ factors b
⊢ a ≤ b

tactic: rwa [factors_prod, factors_prod] at this
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
h : factors a ≤ factors b
this : FactorSet.prod (factors a) ≤ FactorSet.prod (factors b)
⊢ a ≤ b
Theorem: List.singleton_perm_singleton
File: Mathlib/Data/List/Perm.lean

tactic: simp
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
a b : α
⊢ [a] ~ [b] ↔ a = b
Theorem: Polynomial.modByMonic_X
File: Mathlib/Data/Polynomial/Div.lean

tactic: rw [← modByMonic_X_sub_C_eq_C_eval, C_0, sub_zero]
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]
⊢ p %ₘ X = ↑C (eval 0 p)
Theorem: Polynomial.eval₂_algebraMap_X
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: conv_rhs => rw [← Polynomial.sum_C_mul_X_pow_eq p]
state_before: R✝ : Type u
S : Type v
T : Type w
A✝ : Type z
A' : Type ?u.303170
B' : Type ?u.303173
a b : R✝
n : ℕ
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B'
inst✝⁵ : CommSemiring R✝
p✝ q r : R✝[X]
inst✝⁴ : Semiring A✝
inst✝³ : Algebra R✝ A✝
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
p : R[X]
f : R[X] →ₐ[R] A
⊢ eval₂ (algebraMap R A) (↑f X) p = ↑f p

tactic: simp only [eval₂_eq_sum, sum_def]
state_before: R✝ : Type u
S : Type v
T : Type w
A✝ : Type z
A' : Type ?u.303170
B' : Type ?u.303173
a b : R✝
n : ℕ
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B'
inst✝⁵ : CommSemiring R✝
p✝ q r : R✝[X]
inst✝⁴ : Semiring A✝
inst✝³ : Algebra R✝ A✝
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
p : R[X]
f : R[X] →ₐ[R] A
⊢ eval₂ (algebraMap R A) (↑f X) p = ↑f (sum p fun n a => ↑C a * X ^ n)

tactic: simp only [f.map_sum, f.map_mul, f.map_pow, eq_intCast, map_intCast]
state_before: R✝ : Type u
S : Type v
T : Type w
A✝ : Type z
A' : Type ?u.303170
B' : Type ?u.303173
a b : R✝
n : ℕ
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B'
inst✝⁵ : CommSemiring R✝
p✝ q r : R✝[X]
inst✝⁴ : Semiring A✝
inst✝³ : Algebra R✝ A✝
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
p : R[X]
f : R[X] →ₐ[R] A
⊢ ∑ n in support p, ↑(algebraMap R A) (coeff p n) * ↑f X ^ n = ↑f (∑ n in support p, ↑C (coeff p n) * X ^ n)

tactic: simp [Polynomial.C_eq_algebraMap]
state_before: R✝ : Type u
S : Type v
T : Type w
A✝ : Type z
A' : Type ?u.303170
B' : Type ?u.303173
a b : R✝
n : ℕ
inst✝⁷ : CommSemiring A'
inst✝⁶ : Semiring B'
inst✝⁵ : CommSemiring R✝
p✝ q r : R✝[X]
inst✝⁴ : Semiring A✝
inst✝³ : Algebra R✝ A✝
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
p : R[X]
f : R[X] →ₐ[R] A
⊢ ∑ n in support p, ↑(algebraMap R A) (coeff p n) * ↑f X ^ n = ∑ x in support p, ↑f (↑C (coeff p x)) * ↑f X ^ x
Theorem: Set.image_mul_right
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [image_eq_preimage_of_inverse] <;> intro c <;> simp
state_before: F : Type ?u.122781
α : Type u_1
β : Type ?u.122787
γ : Type ?u.122790
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => x * b) '' t = (fun x => x * b⁻¹) ⁻¹' t
Theorem: Submodule.sup_span
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [Submodule.span_union, p.span_eq]
state_before: R : Type u_2
R₂ : Type ?u.48643
K : Type ?u.48646
M : Type u_1
M₂ : Type ?u.48652
V : Type ?u.48655
S : Type ?u.48658
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ p ⊔ span R s = span R (↑p ∪ s)
Theorem: CategoryTheory.GrothendieckTopology.toSheafify_comp_sheafifyCompIso_inv
File: Mathlib/CategoryTheory/Sites/CompatibleSheafification.lean

tactic: rw [Iso.comp_inv_eq]
state_before: C : Type u
inst✝⁸ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category D
E : Type w₂
inst✝⁶ : Category E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ toSheafify J (P ⋙ F) ≫ (sheafifyCompIso J F P).inv = whiskerRight (toSheafify J P) F

tactic: simp
state_before: C : Type u
inst✝⁸ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category D
E : Type w₂
inst✝⁶ : Category E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ toSheafify J (P ⋙ F) = whiskerRight (toSheafify J P) F ≫ (sheafifyCompIso J F P).hom
Theorem: List.headI_add_tail_sum
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: cases L <;> simp
state_before: ι : Type ?u.160749
α : Type ?u.160752
M : Type ?u.160755
N : Type ?u.160758
P : Type ?u.160761
M₀ : Type ?u.160764
G : Type ?u.160767
R : Type ?u.160770
L : List ℕ
⊢ headI L + sum (tail L) = sum L
Theorem: summable_of_norm_bounded
File: Mathlib/Analysis/Normed/Group/InfiniteSum.lean

tactic: rw [summable_iff_cauchySeq_finset]
state_before: ι : Type u_2
α : Type ?u.14525
E : Type u_1
F : Type ?u.14531
inst✝² : SeminormedAddCommGroup E
inst✝¹ : SeminormedAddCommGroup F
inst✝ : CompleteSpace E
f : ι → E
g : ι → ℝ
hg : Summable g
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ Summable f

tactic: exact cauchySeq_finset_of_norm_bounded g hg h
state_before: ι : Type u_2
α : Type ?u.14525
E : Type u_1
F : Type ?u.14531
inst✝² : SeminormedAddCommGroup E
inst✝¹ : SeminormedAddCommGroup F
inst✝ : CompleteSpace E
f : ι → E
g : ι → ℝ
hg : Summable g
h : ∀ (i : ι), ‖f i‖ ≤ g i
⊢ CauchySeq fun s => ∑ b in s, f b
Theorem: IntervalIntegrable.intervalIntegrable_norm_iff
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp_rw [intervalIntegrable_iff, IntegrableOn]
state_before: ι : Type ?u.3012325
𝕜 : Type ?u.3012328
E : Type u_1
F : Type ?u.3012334
A : Type ?u.3012337
inst✝ : NormedAddCommGroup E
f✝ : ℝ → E
a✝ b✝ c d : ℝ
μ✝ ν : MeasureTheory.Measure ℝ
f : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
hf : AEStronglyMeasurable f (Measure.restrict μ (Ι a b))
⊢ IntervalIntegrable (fun t => ‖f t‖) μ a b ↔ IntervalIntegrable f μ a b

tactic: exact integrable_norm_iff hf
state_before: ι : Type ?u.3012325
𝕜 : Type ?u.3012328
E : Type u_1
F : Type ?u.3012334
A : Type ?u.3012337
inst✝ : NormedAddCommGroup E
f✝ : ℝ → E
a✝ b✝ c d : ℝ
μ✝ ν : MeasureTheory.Measure ℝ
f : ℝ → E
μ : MeasureTheory.Measure ℝ
a b : ℝ
hf : AEStronglyMeasurable f (Measure.restrict μ (Ι a b))
⊢ (Integrable fun t => ‖f t‖) ↔ Integrable f
Theorem: MeasureTheory.IsFundamentalDomain.lintegral_eq_tsum_of_ac
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [← lintegral_sum_measure, h.sum_restrict_of_ac hν]
state_before: G : Type u_1
H : Type ?u.165138
α : Type u_2
β : Type ?u.165144
E : Type ?u.165147
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s
hν : ν ≪ μ
f : α → ℝ≥0∞
⊢ (∫⁻ (x : α), f x ∂ν) = ∑' (g : G), ∫⁻ (x : α) in g • s, f x ∂ν
Theorem: Polynomial.derivative_comp_one_sub_X
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp [derivative_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
⊢ ↑derivative (comp p (1 - X)) = -comp (↑derivative p) (1 - X)
Theorem: CategoryTheory.isDetecting_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [← isCodetecting_op_iff, Set.unop_op]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set Cᵒᵖ
⊢ IsDetecting (Set.unop 𝒢) ↔ IsCodetecting 𝒢
Theorem: Cardinal.aleph'_isNormal
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp [ord_le, aleph'_le_of_limit l]
state_before: o : Ordinal
l : Ordinal.IsLimit o
a : Ordinal
⊢ (ord ∘ aleph') o ≤ a ↔ ∀ (b : Ordinal), b < o → (ord ∘ aleph') b ≤ a
Theorem: Cardinal.mk_real
File: Mathlib/Data/Real/Cardinality.lean

tactic: apply le_antisymm
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ (#ℝ) = 𝔠

tactic: rw [Real.equivCauchy.cardinal_eq]
state_before: case a
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ (#ℝ) ≤ 𝔠

tactic: apply mk_quotient_le.trans
state_before: case a
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ (#CauSeq.Completion.Cauchy abs) ≤ 𝔠

tactic: apply (mk_subtype_le _).trans_eq
state_before: case a
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ (#CauSeq ℚ abs) ≤ 𝔠

tactic: rw [← power_def, mk_nat, mkRat, aleph0_power_aleph0]
state_before: case a
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ (#ℕ → ℚ) = 𝔠

tactic: convert mk_le_of_injective (cantorFunction_injective _ _)
state_before: case a
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 𝔠 ≤ (#ℝ)

tactic: rw [← power_def, mk_bool, mk_nat, two_power_aleph0]
state_before: case h.e'_3
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 𝔠 = (#ℕ → Bool)

case a.convert_1
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ ℝ

case a.convert_2
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 0 < ?a.convert_1✝

case a.convert_3
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ ?a.convert_1✝ < 1 / 2

tactic: exact 1 / 3
state_before: case a.convert_1
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ ℝ

case a.convert_2
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 0 < ?a.convert_1✝

case a.convert_3
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ ?a.convert_1✝ < 1 / 2

tactic: norm_num
state_before: case a.convert_2
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 0 < 1 / 3

case a.convert_3
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 1 / 3 < 1 / 2

tactic: norm_num
state_before: case a.convert_3
c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ 1 / 3 < 1 / 2
Theorem: Mathlib.Meta.NormNum.isRat_neg
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [← neg_mul, ← Int.cast_neg]
state_before: α : Type u_1
inst✝ : Ring α
num✝ : ℤ
denom✝ : ℕ
h : Invertible ↑denom✝
⊢ -(↑num✝ * ⅟↑denom✝) = ↑(Int.neg num✝) * ⅟↑denom✝

tactic: rfl
state_before: α : Type u_1
inst✝ : Ring α
num✝ : ℤ
denom✝ : ℕ
h : Invertible ↑denom✝
⊢ ↑(-num✝) * ⅟↑denom✝ = ↑(Int.neg num✝) * ⅟↑denom✝