tasksource/leandojo huggingface dataset:
Theorem: essSup_mono_measure
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: refine' limsup_le_limsup_of_le (Measure.ae_le_iff_absolutelyContinuous.mpr hμν) _ _
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : ν ≪ μ
⊢ essSup f ν ≤ essSup f μ

tactic: all_goals isBoundedDefault
state_before: case refine'_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : ν ≪ μ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae ν) f

case refine'_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : ν ≪ μ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) f

tactic: isBoundedDefault
state_before: case refine'_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : CompleteLattice β
f : α → β
hμν : ν ≪ μ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) f
Theorem: IsHausdorff.subsingleton
File: Mathlib/LinearAlgebra/AdicCompletion.lean

tactic: rw [Ideal.top_pow, top_smul]
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type ?u.100819
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsHausdorff ⊤ M
x y : M
n : ℕ
⊢ x - y ≡ 0 [SMOD ⊤ ^ n • ⊤]

tactic: exact SModEq.top
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type ?u.100819
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsHausdorff ⊤ M
x y : M
n : ℕ
⊢ x - y ≡ 0 [SMOD ⊤]
Theorem: Set.Finite.of_finite_image
File: Mathlib/Data/Set/Finite.lean

tactic: cases h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → β
h : Set.Finite (f '' s)
hi : InjOn f s
⊢ Set.Finite s

tactic: exact
  ⟨Fintype.ofInjective (fun a => (⟨f a.1, mem_image_of_mem f a.2⟩ : f '' s)) fun a b eq =>
      Subtype.eq <| hi a.2 b.2 <| Subtype.ext_iff_val.1 eq⟩
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → β
hi : InjOn f s
a✝ : Fintype ↑(f '' s)
⊢ Set.Finite s
Theorem: Function.Antiperiodic.nat_mul_eq_of_eq_zero
File: Mathlib/Algebra/Periodic.lean

tactic: rwa [Nat.cast_zero, zero_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.160104
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : NegZeroClass β
h : Antiperiodic f c
hi : f 0 = 0
⊢ f (↑0 * c) = 0

tactic: simp [add_mul, h _, Antiperiodic.nat_mul_eq_of_eq_zero h hi n]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.160104
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : NegZeroClass β
h : Antiperiodic f c
hi : f 0 = 0
n : ℕ
⊢ f (↑(n + 1) * c) = 0
Theorem: Function.Antiperiodic.mul
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.221730
f g : α → β
c c₁ c₂ x : α
inst✝² : Add α
inst✝¹ : Mul β
inst✝ : HasDistribNeg β
hf : Antiperiodic f c
hg : Antiperiodic g c
⊢ Periodic (f * g) c
Theorem: Real.continuousAt_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: cases' p with x y
state_before: p : ℝ × ℝ
hp : 0 < p.snd
⊢ ContinuousAt (fun p => p.fst ^ p.snd) p

tactic: dsimp only at hp
state_before: case mk
x y : ℝ
hp : 0 < (x, y).snd
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (x, y)

tactic: obtain hx | rfl := ne_or_eq x 0
state_before: case mk
x y : ℝ
hp : 0 < y
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (x, y)

tactic: have A : Tendsto (fun p : ℝ × ℝ => exp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0) :=
  tendsto_exp_atBot.comp
    ((tendsto_log_nhdsWithin_zero.comp tendsto_fst).atBot_mul hp tendsto_snd)
state_before: case mk.inr
y : ℝ
hp : 0 < y
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (0, y)

tactic: have B : Tendsto (fun p : ℝ × ℝ => p.1 ^ p.2) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0) :=
  squeeze_zero_norm (fun p => abs_rpow_le_exp_log_mul p.1 p.2) A
state_before: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => exp (log p.fst * p.snd)) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (0, y)

tactic: have C : Tendsto (fun p : ℝ × ℝ => p.1 ^ p.2) (𝓝[{0}] 0 ×ˢ 𝓝 y) (pure 0) := by
  rw [nhdsWithin_singleton, tendsto_pure, pure_prod, eventually_map]
  exact (lt_mem_nhds hp).mono fun y hy => zero_rpow hy.ne'
state_before: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => exp (log p.fst * p.snd)) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.fst ^ p.snd) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (0, y)

tactic: simpa only [← sup_prod, ← nhdsWithin_union, compl_union_self, nhdsWithin_univ, nhds_prod_eq,
  ContinuousAt, zero_rpow hp.ne'] using B.sup (C.mono_right (pure_le_nhds _))
state_before: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => exp (log p.fst * p.snd)) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.fst ^ p.snd) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
C : Tendsto (fun p => p.fst ^ p.snd) (𝓝[{0}] 0 ×ˢ 𝓝 y) (pure 0)
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (0, y)

tactic: exact continuousAt_rpow_of_ne (x, y) hx
state_before: case mk.inl
x y : ℝ
hp : 0 < y
hx : x ≠ 0
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (x, y)

tactic: rw [nhdsWithin_singleton, tendsto_pure, pure_prod, eventually_map]
state_before: y : ℝ
hp : 0 < y
A : Tendsto (fun p => exp (log p.fst * p.snd)) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.fst ^ p.snd) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ Tendsto (fun p => p.fst ^ p.snd) (𝓝[{0}] 0 ×ˢ 𝓝 y) (pure 0)

tactic: exact (lt_mem_nhds hp).mono fun y hy => zero_rpow hy.ne'
state_before: y : ℝ
hp : 0 < y
A : Tendsto (fun p => exp (log p.fst * p.snd)) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.fst ^ p.snd) (𝓝[{0}ᶜ] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ∀ᶠ (a : ℝ) in 𝓝 y, (0, a).fst ^ (0, a).snd = 0
Theorem: Option.getD_of_ne_none
File: Std/Data/Option/Lemmas.lean

tactic: cases x
state_before: α : Type u_1
x : Option α
hx : x ≠ none
y : α
⊢ some (getD x y) = x

tactic: {contradiction}
state_before: case none
α : Type u_1
y : α
hx : none ≠ none
⊢ some (getD none y) = none

case some
α : Type u_1
y val✝ : α
hx : some val✝ ≠ none
⊢ some (getD (some val✝) y) = some val✝

tactic: rw [getD_some]
state_before: case some
α : Type u_1
y val✝ : α
hx : some val✝ ≠ none
⊢ some (getD (some val✝) y) = some val✝
Theorem: InnerProductSpace.Core.inner_im_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, conj_im]
state_before: 𝕜 : Type u_1
E : Type ?u.431471
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ↑im (inner x y) = -↑im (inner y x)
Theorem: Finset.coe_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [and_comm, Set.mem_diff, Set.mem_singleton_iff, mem_coe]
state_before: α : Type u_1
β : Type ?u.213387
γ : Type ?u.213390
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
x✝ : α
⊢ x✝ ≠ a ∧ x✝ ∈ s ↔ x✝ ∈ ↑s \ {a}
Theorem: Filter.frequently_true_iff_neBot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [Filter.Frequently, -not_eventually, eventually_false_iff_eq_bot, neBot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.161697
ι : Sort x
f : Filter α
⊢ (∃ᶠ (x : α) in f, True) ↔ NeBot f
Theorem: Class.mem_of_mem_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: obtain ⟨w, rfl, hw⟩ := hy
state_before: x y z : Class
hy : y ∈ ⋂₀ x
hz : z ∈ x
⊢ y ∈ z

tactic: exact coe_mem.2 (hw z hz)
state_before: case intro.intro
x z : Class
hz : z ∈ x
w : ZFSet
hw : (⋂₀ x) w
⊢ ↑w ∈ z
Theorem: CharP.cast_card_eq_zero
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [← nsmul_one, card_nsmul_eq_zero]
state_before: R : Type u_1
inst✝¹ : AddGroupWithOne R
inst✝ : Fintype R
⊢ ↑(Fintype.card R) = 0
Theorem: TensorProduct.toMatrix_comm
File: Mathlib/LinearAlgebra/TensorProduct/Matrix.lean

tactic: ext (⟨i, j⟩⟨i', j'⟩)
state_before: R : Type u_1
M : Type u_4
N : Type u_5
P : Type ?u.152592
M' : Type ?u.152595
N' : Type ?u.152598
ι : Type u_2
κ : Type u_3
τ : Type ?u.152607
ι' : Type ?u.152610
κ' : Type ?u.152613
inst✝¹⁸ : DecidableEq ι
inst✝¹⁷ : DecidableEq κ
inst✝¹⁶ : DecidableEq τ
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype κ
inst✝¹³ : Fintype τ
inst✝¹² : Fintype ι'
inst✝¹¹ : Fintype κ'
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R M'
inst✝ : Module R N'
bM : Basis ι R M
bN : Basis κ R N
bP : Basis τ R P
bM' : Basis ι' R M'
bN' : Basis κ' R N'
⊢ ↑(toMatrix (Basis.tensorProduct bM bN) (Basis.tensorProduct bN bM)) ↑(TensorProduct.comm R M N) =
    submatrix 1 Prod.swap _root_.id

tactic: simp_rw [toMatrix_apply, Basis.tensorProduct_apply, LinearEquiv.coe_coe, TensorProduct.comm_tmul,
  Basis.tensorProduct_repr_tmul_apply, Matrix.submatrix_apply, Prod.swap_prod_mk, id.def,
  Basis.repr_self_apply, Matrix.one_apply, Prod.ext_iff, ite_and, @eq_comm _ i', @eq_comm _ j']
state_before: case a.mk.h.mk
R : Type u_1
M : Type u_4
N : Type u_5
P : Type ?u.152592
M' : Type ?u.152595
N' : Type ?u.152598
ι : Type u_2
κ : Type u_3
τ : Type ?u.152607
ι' : Type ?u.152610
κ' : Type ?u.152613
inst✝¹⁸ : DecidableEq ι
inst✝¹⁷ : DecidableEq κ
inst✝¹⁶ : DecidableEq τ
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype κ
inst✝¹³ : Fintype τ
inst✝¹² : Fintype ι'
inst✝¹¹ : Fintype κ'
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R M'
inst✝ : Module R N'
bM : Basis ι R M
bN : Basis κ R N
bP : Basis τ R P
bM' : Basis ι' R M'
bN' : Basis κ' R N'
i : κ
j i' : ι
j' : κ
⊢ ↑(toMatrix (Basis.tensorProduct bM bN) (Basis.tensorProduct bN bM)) ↑(TensorProduct.comm R M N) (i, j) (i', j') =
    submatrix 1 Prod.swap _root_.id (i, j) (i', j')

tactic: split_ifs <;> simp
state_before: case a.mk.h.mk
R : Type u_1
M : Type u_4
N : Type u_5
P : Type ?u.152592
M' : Type ?u.152595
N' : Type ?u.152598
ι : Type u_2
κ : Type u_3
τ : Type ?u.152607
ι' : Type ?u.152610
κ' : Type ?u.152613
inst✝¹⁸ : DecidableEq ι
inst✝¹⁷ : DecidableEq κ
inst✝¹⁶ : DecidableEq τ
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype κ
inst✝¹³ : Fintype τ
inst✝¹² : Fintype ι'
inst✝¹¹ : Fintype κ'
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R M'
inst✝ : Module R N'
bM : Basis ι R M
bN : Basis κ R N
bP : Basis τ R P
bM' : Basis ι' R M'
bN' : Basis κ' R N'
i : κ
j i' : ι
j' : κ
⊢ ((if i = j' then 1 else 0) * if j = i' then 1 else 0) = if j = i' then if i = j' then 1 else 0 else 0
Theorem: List.Ico.not_mem_top
File: Mathlib/Data/List/Intervals.lean

tactic: simp
state_before: n m : ℕ
⊢ ¬m ∈ Ico n m
Theorem: CategoryTheory.Limits.prod.map_map
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝³ : Category C
X Y A₁ A₂ A₃ B₁ B₂ B₃ : C
inst✝² : HasBinaryProduct A₁ B₁
inst✝¹ : HasBinaryProduct A₂ B₂
inst✝ : HasBinaryProduct A₃ B₃
f : A₁ ⟶ A₂
g : B₁ ⟶ B₂
h : A₂ ⟶ A₃
k : B₂ ⟶ B₃
⊢ map f g ≫ map h k = map (f ≫ h) (g ≫ k)

tactic: simp
state_before: case h₁
C : Type u
inst✝³ : Category C
X Y A₁ A₂ A₃ B₁ B₂ B₃ : C
inst✝² : HasBinaryProduct A₁ B₁
inst✝¹ : HasBinaryProduct A₂ B₂
inst✝ : HasBinaryProduct A₃ B₃
f : A₁ ⟶ A₂
g : B₁ ⟶ B₂
h : A₂ ⟶ A₃
k : B₂ ⟶ B₃
⊢ (map f g ≫ map h k) ≫ fst = map (f ≫ h) (g ≫ k) ≫ fst

case h₂
C : Type u
inst✝³ : Category C
X Y A₁ A₂ A₃ B₁ B₂ B₃ : C
inst✝² : HasBinaryProduct A₁ B₁
inst✝¹ : HasBinaryProduct A₂ B₂
inst✝ : HasBinaryProduct A₃ B₃
f : A₁ ⟶ A₂
g : B₁ ⟶ B₂
h : A₂ ⟶ A₃
k : B₂ ⟶ B₃
⊢ (map f g ≫ map h k) ≫ snd = map (f ≫ h) (g ≫ k) ≫ snd

tactic: simp
state_before: case h₂
C : Type u
inst✝³ : Category C
X Y A₁ A₂ A₃ B₁ B₂ B₃ : C
inst✝² : HasBinaryProduct A₁ B₁
inst✝¹ : HasBinaryProduct A₂ B₂
inst✝ : HasBinaryProduct A₃ B₃
f : A₁ ⟶ A₂
g : B₁ ⟶ B₂
h : A₂ ⟶ A₃
k : B₂ ⟶ B₃
⊢ (map f g ≫ map h k) ≫ snd = map (f ≫ h) (g ≫ k) ≫ snd
Theorem: DiscreteValuationRing.eq_unit_mul_pow_irreducible
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: obtain ⟨n, hn⟩ := associated_pow_irreducible hx hirr
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
x : R
hx : x ≠ 0
ϖ : R
hirr : Irreducible ϖ
⊢ ∃ n u, x = ↑u * ϖ ^ n

tactic: obtain ⟨u, rfl⟩ := hn.symm
state_before: case intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
x : R
hx : x ≠ 0
ϖ : R
hirr : Irreducible ϖ
n : ℕ
hn : Associated x (ϖ ^ n)
⊢ ∃ n u, x = ↑u * ϖ ^ n

tactic: use n, u
state_before: case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
ϖ : R
hirr : Irreducible ϖ
n : ℕ
u : Rˣ
hx : ϖ ^ n * ↑u ≠ 0
hn : Associated (ϖ ^ n * ↑u) (ϖ ^ n)
⊢ ∃ n_1 u_1, ϖ ^ n * ↑u = ↑u_1 * ϖ ^ n_1

tactic: apply mul_comm
state_before: case intro.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
ϖ : R
hirr : Irreducible ϖ
n : ℕ
u : Rˣ
hx : ϖ ^ n * ↑u ≠ 0
hn : Associated (ϖ ^ n * ↑u) (ϖ ^ n)
⊢ ϖ ^ n * ↑u = ↑u * ϖ ^ n
Theorem: DiscreteQuotient.LEComap.comp
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: tauto
state_before: α : Type ?u.26859
X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
⊢ LEComap g B C → LEComap f A B → LEComap (ContinuousMap.comp g f) A C
Theorem: Normal.exists_isSplittingField
File: Mathlib/FieldTheory/Normal.lean

tactic: let s := Basis.ofVectorSpace F K
state_before: F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
⊢ ∃ p, IsSplittingField F K p

tactic: refine'
  ⟨∏ x, minpoly F (s x), splits_prod _ fun x _ => h.splits (s x),
    Subalgebra.toSubmodule.injective _⟩
state_before: F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
⊢ ∃ p, IsSplittingField F K p

tactic: rw [Algebra.top_toSubmodule, eq_top_iff, ← s.span_eq, Submodule.span_le, Set.range_subset_iff]
state_before: F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
⊢ ↑Subalgebra.toSubmodule
      (Algebra.adjoin F
        ↑(Multiset.toFinset (roots (map (algebraMap F K) (∏ x : ↑(Basis.ofVectorSpaceIndex F K), minpoly F (↑s x)))))) =
    ↑Subalgebra.toSubmodule ⊤

tactic: refine' fun x =>
  Algebra.subset_adjoin
    (Multiset.mem_toFinset.mpr <|
      (mem_roots <|
            mt (Polynomial.map_eq_zero <| algebraMap F K).1 <|
              Finset.prod_ne_zero_iff.2 fun x _ => _).2
        _)
state_before: F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
⊢ ∀ (y : ↑(Basis.ofVectorSpaceIndex F K)),
    ↑s y ∈
      ↑(↑Subalgebra.toSubmodule
          (Algebra.adjoin F
            ↑(Multiset.toFinset
                (roots (map (algebraMap F K) (∏ x : ↑(Basis.ofVectorSpaceIndex F K), minpoly F (↑s x)))))))

tactic: rw [IsRoot.def, eval_map, ← aeval_def, AlgHom.map_prod]
state_before: case refine'_2
F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
x : ↑(Basis.ofVectorSpaceIndex F K)
⊢ IsRoot (map (algebraMap F K) (∏ x : ↑(Basis.ofVectorSpaceIndex F K), minpoly F (↑s x))) (↑s x)

tactic: exact Finset.prod_eq_zero (Finset.mem_univ _) (minpoly.aeval _ _)
state_before: case refine'_2
F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
x : ↑(Basis.ofVectorSpaceIndex F K)
⊢ ∏ x_1 : ↑(Basis.ofVectorSpaceIndex F K), ↑(aeval (↑s x)) (minpoly F (↑s x_1)) = 0

tactic: exact minpoly.ne_zero (h.isIntegral (s x))
state_before: case refine'_1
F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
x✝¹ x : ↑(Basis.ofVectorSpaceIndex F K)
x✝ : x ∈ Finset.univ
⊢ minpoly F (↑s x) ≠ 0
Theorem: Int.coe_leastOfBdd_eq
File: Mathlib/Data/Int/LeastGreatest.lean

tactic: rcases leastOfBdd b Hb Hinh with ⟨n, hn, h2n⟩
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
⊢ ↑(leastOfBdd b Hb Hinh) = ↑(leastOfBdd b' Hb' Hinh)

tactic: rcases leastOfBdd b' Hb' Hinh with ⟨n', hn', h2n'⟩
state_before: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
⊢ ↑{ val := n, property := (_ : P n ∧ ∀ (z : ℤ), P z → n ≤ z) } = ↑(leastOfBdd b' Hb' Hinh)

tactic: exact le_antisymm (h2n _ hn') (h2n' _ hn)
state_before: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → n' ≤ z
⊢ ↑{ val := n, property := (_ : P n ∧ ∀ (z : ℤ), P z → n ≤ z) } =
    ↑{ val := n', property := (_ : P n' ∧ ∀ (z : ℤ), P z → n' ≤ z) }
Theorem: IsSMulRegular.subsingleton
File: Mathlib/Algebra/Regular/SMul.lean

tactic: dsimp only [Function.comp]
state_before: R : Type u_1
S : Type ?u.24255
M : Type u_2
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ (fun x => 0 • x) a = (fun x => 0 • x) b

tactic: repeat' rw [MulActionWithZero.zero_smul]
state_before: R : Type u_1
S : Type ?u.24255
M : Type u_2
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ 0 • a = 0 • b

tactic: rw [MulActionWithZero.zero_smul]
state_before: R : Type u_1
S : Type ?u.24255
M : Type u_2
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ 0 = 0 • b
Theorem: CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [pullbackSymmetry]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).hom ≫ pullback.snd = pullback.fst
Theorem: Int.natAbs_abs
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [abs_eq_natAbs]
state_before: a : ℤ
⊢ natAbs (abs a) = natAbs a

tactic: rfl
state_before: a : ℤ
⊢ natAbs ↑(natAbs a) = natAbs a
Theorem: range_pow_padicValNat_subset_divisors'
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
⊢ Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p n)) ⊆ Finset.erase (divisors n) 1

tactic: intro t ht
state_before: case inr
p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
⊢ Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p n)) ⊆ Finset.erase (divisors n) 1

tactic: simp only [exists_prop, Finset.mem_image, Finset.mem_range] at ht
state_before: case inr
p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
t : ℕ
ht : t ∈ Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p n))
⊢ t ∈ Finset.erase (divisors n) 1

tactic: obtain ⟨k, hk, rfl⟩ := ht
state_before: case inr
p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
t : ℕ
ht : ∃ a, a < padicValNat p n ∧ p ^ (a + 1) = t
⊢ t ∈ Finset.erase (divisors n) 1

tactic: rw [Finset.mem_erase, Nat.mem_divisors]
state_before: case inr.intro.intro
p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
k : ℕ
hk : k < padicValNat p n
⊢ p ^ (k + 1) ∈ Finset.erase (divisors n) 1

tactic: refine' ⟨_, (pow_dvd_pow p <| succ_le_iff.2 hk).trans pow_padicValNat_dvd, hn⟩
state_before: case inr.intro.intro
p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
k : ℕ
hk : k < padicValNat p n
⊢ p ^ (k + 1) ≠ 1 ∧ p ^ (k + 1) ∣ n ∧ n ≠ 0

tactic: exact (Nat.one_lt_pow _ _ k.succ_pos hp.out.one_lt).ne'
state_before: case inr.intro.intro
p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
k : ℕ
hk : k < padicValNat p n
⊢ p ^ (k + 1) ≠ 1

tactic: simp
state_before: case inl
p : ℕ
hp : Fact (Nat.Prime p)
⊢ Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p 0)) ⊆ Finset.erase (divisors 0) 1
Theorem: MeasureTheory.withDensity_ofReal_mutuallySingular
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: set S : Set α := { x | f x < 0 }
state_before: α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
⊢ (withDensity μ fun x => ENNReal.ofReal (f x)) ⟂ₘ withDensity μ fun x => ENNReal.ofReal (-f x)

tactic: have hS : MeasurableSet S := measurableSet_lt hf measurable_const
state_before: α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
S : Set α := {x | f x < 0}
⊢ (withDensity μ fun x => ENNReal.ofReal (f x)) ⟂ₘ withDensity μ fun x => ENNReal.ofReal (-f x)

tactic: refine' ⟨S, hS, _, _⟩
state_before: α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
S : Set α := {x | f x < 0}
hS : MeasurableSet S
⊢ (withDensity μ fun x => ENNReal.ofReal (f x)) ⟂ₘ withDensity μ fun x => ENNReal.ofReal (-f x)

tactic: rw [withDensity_apply _ hS, lintegral_eq_zero_iff hf.ennreal_ofReal, EventuallyEq]
state_before: case refine'_1
α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
S : Set α := {x | f x < 0}
hS : MeasurableSet S
⊢ ↑↑(withDensity μ fun x => ENNReal.ofReal (f x)) S = 0

tactic: exact (ae_restrict_mem hS).mono fun x hx => ENNReal.ofReal_eq_zero.2 (le_of_lt hx)
state_before: case refine'_1
α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
S : Set α := {x | f x < 0}
hS : MeasurableSet S
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ S, ENNReal.ofReal (f x) = OfNat.ofNat 0 x

tactic: rw [withDensity_apply _ hS.compl, lintegral_eq_zero_iff hf.neg.ennreal_ofReal, EventuallyEq]
state_before: case refine'_2
α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
S : Set α := {x | f x < 0}
hS : MeasurableSet S
⊢ ↑↑(withDensity μ fun x => ENNReal.ofReal (-f x)) (Sᶜ) = 0

tactic: exact
  (ae_restrict_mem hS.compl).mono fun x hx =>
    ENNReal.ofReal_eq_zero.2 (not_lt.1 <| mt neg_pos.1 hx)
state_before: case refine'_2
α : Type u_1
β : Type ?u.1769647
γ : Type ?u.1769650
δ : Type ?u.1769653
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
hf : Measurable f
S : Set α := {x | f x < 0}
hS : MeasurableSet S
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ (Sᶜ), ENNReal.ofReal (-f x) = OfNat.ofNat 0 x