tasksource/leandojo huggingface dataset:
Theorem: TopCat.Presheaf.germ_ext
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: erw [← F.germ_res iWU ⟨x, hxW⟩, ← F.germ_res iWV ⟨x, hxW⟩, comp_apply, comp_apply, ih]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasColimits C
X Y Z : TopCat
inst✝ : ConcreteCategory C
F : Presheaf C X
U V : Opens ↑X
x : ↑X
hxU : x ∈ U
hxV : x ∈ V
W : Opens ↑X
hxW : x ∈ W
iWU : W ⟶ U
iWV : W ⟶ V
sU : (forget C).obj (F.obj U.op)
sV : (forget C).obj (F.obj V.op)
ih : (forget C).map (F.map iWU.op) sU = (forget C).map (F.map iWV.op) sV
⊢ (forget C).map (germ F { val := x, property := hxU }) sU = (forget C).map (germ F { val := x, property := hxV }) sV
Theorem: gramSchmidt_zero
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: rw [gramSchmidt_def, Iio_eq_Ico, Finset.Ico_self, Finset.sum_empty, sub_zero]
state_before: 𝕜 : Type u_3
E : Type u_2
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
ι✝ : Type ?u.43983
inst✝⁶ : LinearOrder ι✝
inst✝⁵ : LocallyFiniteOrderBot ι✝
inst✝⁴ : IsWellOrder ι✝ fun x x_1 => x < x_1
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : LocallyFiniteOrder ι
inst✝¹ : OrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
⊢ gramSchmidt 𝕜 f ⊥ = f ⊥
Theorem: IsLocalizedModule.mk'_eq_zero
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [mk'_eq_iff, smul_zero]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.907116
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s : { x // x ∈ S }
⊢ mk' f m s = 0 ↔ ↑f m = 0
Theorem: LinearIsometry.inner_map_map
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp [inner_eq_sum_norm_sq_div_four, ← f.norm_map]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2760926
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type ?u.2760975
ι' : Type ?u.2760978
ι'' : Type ?u.2760981
E' : Type u_3
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type ?u.2761002
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
f : E →ₗᵢ[𝕜] E'
x y : E
⊢ inner (↑f x) (↑f y) = inner x y
Theorem: subset_iterate_compRel
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: induction' n with n ihn generalizing t
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.16476
s t : Set (α × α)
h : idRel ⊆ s
n : ℕ
⊢ t ⊆ ((fun x x_1 => x ○ x_1) s^[n]) t

tactic: exacts [Subset.rfl, (right_subset_compRel h).trans ihn]
state_before: case zero
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.16476
s t✝ : Set (α × α)
h : idRel ⊆ s
t : Set (α × α)
⊢ t ⊆ ((fun x x_1 => x ○ x_1) s^[Nat.zero]) t

case succ
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.16476
s t✝ : Set (α × α)
h : idRel ⊆ s
n : ℕ
ihn : ∀ {t : Set (α × α)}, t ⊆ ((fun x x_1 => x ○ x_1) s^[n]) t
t : Set (α × α)
⊢ t ⊆ ((fun x x_1 => x ○ x_1) s^[Nat.succ n]) t
Theorem: newton_seq_succ_dist_weak
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: have := pow_le_pow (by norm_num : 1 ≤ 2) (Nat.le_add_left _ _ : 1 ≤ n + 1)
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ 2 ≤ 2 ^ (n + 1)

tactic: simpa using this
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
this : 2 ^ 1 ≤ 2 ^ (n + 1)
⊢ 2 ≤ 2 ^ (n + 1)

tactic: norm_num
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ 1 ≤ 2

tactic: norm_num
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
this : 2 ≤ 2 ^ (n + 1)
⊢ 1 < 2

tactic: rw [T_gen, sq, pow_one, norm_div, ← mul_div_assoc, PadicInt.padic_norm_e_of_padicInt,
  PadicInt.coe_mul, padicNormE.mul]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
this : 2 ≤ 2 ^ (n + 1)
⊢ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 1 =
    ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: apply mul_div_mul_left
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
this : 2 ≤ 2 ^ (n + 1)
⊢ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * ‖Polynomial.eval a F‖ /
      (‖↑(Polynomial.eval a (↑Polynomial.derivative F))‖ * ‖↑(Polynomial.eval a (↑Polynomial.derivative F))‖) =
    ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: apply deriv_norm_ne_zero
state_before: case hc
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
this : 2 ≤ 2 ^ (n + 1)
⊢ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ≠ 0

tactic: assumption
state_before: case hc.hnorm
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
this : 2 ≤ 2 ^ (n + 1)
⊢ ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
Theorem: Matrix.vecMul_vecMul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.884429
m : Type u_2
n : Type u_1
o : Type u_3
m' : o → Type ?u.884443
n' : o → Type ?u.884448
R : Type ?u.884451
S : Type ?u.884454
α : Type v
β : Type w
γ : Type ?u.884461
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype m
v : m → α
M : Matrix m n α
N : Matrix n o α
⊢ vecMul (vecMul v M) N = vecMul v (M ⬝ N)

tactic: apply dotProduct_assoc
state_before: case h
l : Type ?u.884429
m : Type u_2
n : Type u_1
o : Type u_3
m' : o → Type ?u.884443
n' : o → Type ?u.884448
R : Type ?u.884451
S : Type ?u.884454
α : Type v
β : Type w
γ : Type ?u.884461
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype m
v : m → α
M : Matrix m n α
N : Matrix n o α
x✝ : o
⊢ vecMul (vecMul v M) N x✝ = vecMul v (M ⬝ N) x✝
Theorem: Polynomial.eq_prod_roots_of_monic_of_splits_id
File: Mathlib/Data/Polynomial/Splits.lean

tactic: convert eq_prod_roots_of_splits_id hsplit
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
m : Monic p
hsplit : Splits (RingHom.id K) p
⊢ p = Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p))

tactic: simp [m]
state_before: case h.e'_3
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
m : Monic p
hsplit : Splits (RingHom.id K) p
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p)) =
    ↑C (leadingCoeff p) * Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p))
Theorem: CategoryTheory.Sieve.image_mem_functorPushforward
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X
V : C
f : V ⟶ X
h : R.arrows f
⊢ F.map f = 𝟙 (F.obj V) ≫ F.map f
Theorem: CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_inv
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
j : J
⊢ t.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).inv = w.inv.app j ≫ s.ι.app j
Theorem: tsum_nonpos
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: by_cases hf : Summable f
state_before: ι : Type u_2
κ : Type ?u.33257
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
h : ∀ (i : ι), f i ≤ 0
⊢ (∑' (i : ι), f i) ≤ 0

tactic: exact hf.hasSum.nonpos h
state_before: case pos
ι : Type u_2
κ : Type ?u.33257
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
h : ∀ (i : ι), f i ≤ 0
hf : Summable f
⊢ (∑' (i : ι), f i) ≤ 0

tactic: rw [tsum_eq_zero_of_not_summable hf]
state_before: case neg
ι : Type u_2
κ : Type ?u.33257
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
h : ∀ (i : ι), f i ≤ 0
hf : ¬Summable f
⊢ (∑' (i : ι), f i) ≤ 0
Theorem: CategoryTheory.eqToHom_op
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: cases h
state_before: C : Type u₁
inst✝ : Category C
X Y : C
h : X = Y
⊢ (eqToHom h).op = eqToHom (_ : Y.op = X.op)

tactic: rfl
state_before: case refl
C : Type u₁
inst✝ : Category C
X : C
⊢ (eqToHom (_ : X = X)).op = eqToHom (_ : X.op = X.op)
Theorem: CategoryTheory.Limits.PullbackCone.mono_snd_of_is_pullback_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: refine ⟨fun {W} h k i => IsLimit.hom_ext ht ?_ i⟩
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
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
⊢ Mono (snd t)

tactic: rw [← cancel_mono f, Category.assoc, Category.assoc, condition]
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
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
⊢ h ≫ fst t = k ≫ fst t

tactic: dsimp at this
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
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
this : (fun x => x ≫ g) (h ≫ snd t) = (fun x => x ≫ g) (k ≫ snd t)
⊢ h ≫ snd t ≫ g = k ≫ snd t ≫ g

tactic: rwa [Category.assoc, Category.assoc] at this
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
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono f
W : C
h k : W ⟶ t.pt
i : h ≫ snd t = k ≫ snd t
this : (h ≫ snd t) ≫ g = (k ≫ snd t) ≫ g
⊢ h ≫ snd t ≫ g = k ≫ snd t ≫ g
Theorem: MeasureTheory.SimpleFunc.memℒp_approxOn_range
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp
state_before: α : Type ?u.720562
β : Type ?u.720565
ι : Type ?u.720568
E : Type ?u.720571
F : Type ?u.720574
𝕜 : Type ?u.720577
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
hf : Memℒp f p
n : ℕ
⊢ 0 ∈ Set.range f ∪ {0}

tactic: simp
state_before: α : Type ?u.720562
β : Type u_2
ι : Type ?u.720568
E : Type u_1
F : Type ?u.720574
𝕜 : Type ?u.720577
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
q : ℝ
p : ℝ≥0∞
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
hf : Memℒp f p
n : ℕ
⊢ 0 ∈ Set.range f ∪ {0}
Theorem: Nat.ArithmeticFunction.moebius_mul_log_eq_vonMangoldt
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: rw [mul_comm]
state_before: ⊢ ↑μ * log = Λ

tactic: simp
state_before: ⊢ log * ↑μ = Λ
Theorem: CategoryTheory.Sieve.effectiveEpimorphic_singleton
File: Mathlib/CategoryTheory/Sites/EffectiveEpimorphic.lean

tactic: constructor
state_before: C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
⊢ Presieve.EffectiveEpimorphic (Presieve.singleton f) ↔ EffectiveEpi f

tactic: intro (h : Nonempty _)
state_before: case mp
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
⊢ Presieve.EffectiveEpimorphic (Presieve.singleton f) → EffectiveEpi f

tactic: rw [Sieve.generateSingleton_eq] at h
state_before: case mp
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
h : Nonempty (IsColimit (Presieve.cocone (generate (Presieve.singleton f)).arrows))
⊢ EffectiveEpi f

tactic: constructor
state_before: case mp
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
h : Nonempty (IsColimit (Presieve.cocone (generateSingleton f).arrows))
⊢ EffectiveEpi f

tactic: apply Nonempty.map (effectiveEpiStructOfIsColimit _) h
state_before: case mp.effectiveEpi
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
h : Nonempty (IsColimit (Presieve.cocone (generateSingleton f).arrows))
⊢ Nonempty (EffectiveEpiStruct f)

tactic: rintro ⟨h⟩
state_before: case mpr
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
⊢ EffectiveEpi f → Presieve.EffectiveEpimorphic (Presieve.singleton f)

tactic: show Nonempty _
state_before: case mpr.mk
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
h : Nonempty (EffectiveEpiStruct f)
⊢ Presieve.EffectiveEpimorphic (Presieve.singleton f)

tactic: rw [Sieve.generateSingleton_eq]
state_before: case mpr.mk
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
h : Nonempty (EffectiveEpiStruct f)
⊢ Nonempty (IsColimit (Presieve.cocone (generate (Presieve.singleton f)).arrows))

tactic: apply Nonempty.map (isColimitOfEffectiveEpiStruct _) h
state_before: case mpr.mk
C : Type u_2
inst✝ : Category C
X Y : C
f : Y ⟶ X
h : Nonempty (EffectiveEpiStruct f)
⊢ Nonempty (IsColimit (Presieve.cocone (generateSingleton f).arrows))
Theorem: mem_nhds_of_pi_mem_nhds
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_pi] at hs
state_before: α : Type u
β : Type v
γ : Type ?u.284474
δ : Type ?u.284477
ε : Type ?u.284480
ζ : Type ?u.284483
ι : Type u_1
π : ι → Type u_2
κ : Type ?u.284494
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f : α → (i : ι) → π i
I : Set ι
s : (i : ι) → Set (π i)
a : (i : ι) → π i
hs : Set.pi I s ∈ 𝓝 a
i : ι
hi : i ∈ I
⊢ s i ∈ 𝓝 (a i)

tactic: exact mem_of_pi_mem_pi hs hi
state_before: α : Type u
β : Type v
γ : Type ?u.284474
δ : Type ?u.284477
ε : Type ?u.284480
ζ : Type ?u.284483
ι : Type u_1
π : ι → Type u_2
κ : Type ?u.284494
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f : α → (i : ι) → π i
I : Set ι
s : (i : ι) → Set (π i)
a : (i : ι) → π i
hs : Set.pi I s ∈ Filter.pi fun i => 𝓝 (a i)
i : ι
hi : i ∈ I
⊢ s i ∈ 𝓝 (a i)
Theorem: zpow_pos_of_pos
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [zpow_ofNat]
state_before: ι : Type ?u.16757
α : Type u_1
β : Type ?u.16763
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 < a
n : ℕ
⊢ 0 < a ^ ↑n

tactic: exact pow_pos ha _
state_before: ι : Type ?u.16757
α : Type u_1
β : Type ?u.16763
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 < a
n : ℕ
⊢ 0 < a ^ n

tactic: rw [zpow_neg, inv_pos, zpow_ofNat]
state_before: ι : Type ?u.16757
α : Type u_1
β : Type ?u.16763
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 < a
n : ℕ
⊢ 0 < a ^ (-↑(n + 1))

tactic: exact pow_pos ha _
state_before: ι : Type ?u.16757
α : Type u_1
β : Type ?u.16763
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 < a
n : ℕ
⊢ 0 < a ^ (n + 1)
Theorem: IsPGroup.comap_of_ker_isPGroup
File: Mathlib/GroupTheory/PGroup.lean

tactic: intro g
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
⊢ IsPGroup p { x // x ∈ Subgroup.comap ϕ H }

tactic: obtain ⟨j, hj⟩ := hH ⟨ϕ g.1, g.2⟩
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
g : { x // x ∈ Subgroup.comap ϕ H }
⊢ ∃ k, g ^ p ^ k = 1

tactic: rw [Subtype.ext_iff, H.coe_pow, Subtype.coe_mk, ← ϕ.map_pow] at hj
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
g : { x // x ∈ Subgroup.comap ϕ H }
j : ℕ
hj : { val := ↑ϕ ↑g, property := (_ : ↑g ∈ Subgroup.comap ϕ H) } ^ p ^ j = 1
⊢ ∃ k, g ^ p ^ k = 1

tactic: obtain ⟨k, hk⟩ := hϕ ⟨g.1 ^ p ^ j, hj⟩
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
g : { x // x ∈ Subgroup.comap ϕ H }
j : ℕ
hj : ↑ϕ (↑g ^ p ^ j) = ↑1
⊢ ∃ k, g ^ p ^ k = 1

tactic: rw [Subtype.ext_iff, ϕ.ker.coe_pow, Subtype.coe_mk, ← pow_mul, ← pow_add] at hk
state_before: case intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
g : { x // x ∈ Subgroup.comap ϕ H }
j : ℕ
hj : ↑ϕ (↑g ^ p ^ j) = ↑1
k : ℕ
hk : { val := ↑g ^ p ^ j, property := hj } ^ p ^ k = 1
⊢ ∃ k, g ^ p ^ k = 1

tactic: exact ⟨j + k, by rwa [Subtype.ext_iff, (H.comap ϕ).coe_pow]⟩
state_before: case intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
g : { x // x ∈ Subgroup.comap ϕ H }
j : ℕ
hj : ↑ϕ (↑g ^ p ^ j) = ↑1
k : ℕ
hk : ↑g ^ p ^ (j + k) = ↑1
⊢ ∃ k, g ^ p ^ k = 1

tactic: rwa [Subtype.ext_iff, (H.comap ϕ).coe_pow]
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
hH : IsPGroup p { x // x ∈ H }
K : Type u_2
inst✝ : Group K
ϕ : K →* G
hϕ : IsPGroup p { x // x ∈ MonoidHom.ker ϕ }
g : { x // x ∈ Subgroup.comap ϕ H }
j : ℕ
hj : ↑ϕ (↑g ^ p ^ j) = ↑1
k : ℕ
hk : ↑g ^ p ^ (j + k) = ↑1
⊢ g ^ p ^ (j + k) = 1
Theorem: Filter.tendsto_comap_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rwa [map_map]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.311472
ι : Sort x
f : α → β
g : β → γ
a : Filter α
c : Filter γ
h : Tendsto (g ∘ f) a c
⊢ map g (map f a) ≤ c
Theorem: affineSpan_coe_preimage_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [eq_top_iff]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.347568
A : Set P
inst✝ : Nonempty ↑A
⊢ affineSpan k (Subtype.val ⁻¹' A) = ⊤

tactic: rintro ⟨x, hx⟩ -
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.347568
A : Set P
inst✝ : Nonempty ↑A
⊢ ⊤ ≤ affineSpan k (Subtype.val ⁻¹' A)

tactic: refine' affineSpan_induction' (fun y hy => _) (fun c u hu v hv w hw => _) hx
    (p := fun y hy => ⟨y, hy⟩ ∈ (affineSpan k (((↑) : {z // z ∈ affineSpan k A} → P) ⁻¹' A)))
state_before: case mk
k : Type u_2
V : Type u_3
P : Type u_1
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.347568
A : Set P
inst✝ : Nonempty ↑A
x : P
hx : x ∈ ↑(affineSpan k A)
⊢ { val := x, property := hx } ∈ ↑(affineSpan k (Subtype.val ⁻¹' A))

tactic: exact subset_affineSpan _ _ hy
state_before: case mk.refine'_1
k : Type u_2
V : Type u_3
P : Type u_1
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.347568
A : Set P
inst✝ : Nonempty ↑A
x : P
hx : x ∈ ↑(affineSpan k A)
y : P
hy : y ∈ A
⊢ (fun y hy => { val := y, property := hy } ∈ affineSpan k (Subtype.val ⁻¹' A)) y (_ : y ∈ ↑(affineSpan k A))

tactic: exact AffineSubspace.smul_vsub_vadd_mem _ _
state_before: case mk.refine'_2
k : Type u_2
V : Type u_3
P : Type u_1
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type ?u.347568
A : Set P
inst✝ : Nonempty ↑A
x : P
hx : x ∈ ↑(affineSpan k A)
c : k
u : P
hu : u ∈ affineSpan k A
v : P
hv : v ∈ affineSpan k A
w : P
hw : w ∈ affineSpan k A
⊢ (fun y hy => { val := y, property := hy } ∈ affineSpan k (Subtype.val ⁻¹' A)) u hu →
    (fun y hy => { val := y, property := hy } ∈ affineSpan k (Subtype.val ⁻¹' A)) v hv →
      (fun y hy => { val := y, property := hy } ∈ affineSpan k (Subtype.val ⁻¹' A)) w hw →
        (fun y hy => { val := y, property := hy } ∈ affineSpan k (Subtype.val ⁻¹' A)) (c • (u -ᵥ v) +ᵥ w)
          (_ : c • (u -ᵥ v) +ᵥ w ∈ (affineSpan k A).carrier)
Theorem: Finset.affineCombinationSingleWeights_apply_self
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [affineCombinationSingleWeights]
state_before: k : Type u_2
V : Type ?u.412241
P : Type ?u.412244
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.412900
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i : ι
⊢ affineCombinationSingleWeights k i i = 1
Theorem: Besicovitch.SatelliteConfig.centerAndRescale_center
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

tactic: simp [SatelliteConfig.centerAndRescale]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
N : ℕ
τ : ℝ
a : SatelliteConfig E N τ
⊢ c (centerAndRescale a) (last N) = 0
Theorem: map_nhds_induced_eq
File: Mathlib/Topology/Order.lean

tactic: rw [nhds_induced, Filter.map_comap, nhdsWithin]
state_before: α : Type u_2
β : Type u_1
t : TopologicalSpace β
f : α → β
a : α
⊢ map f (𝓝 a) = 𝓝[range f] f a
Theorem: LinearMap.prod_eq_sup_map
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [← map_coprod_prod, coprod_inl_inr, map_id]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.220276
M₆ : Type ?u.220279
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
p : Submodule R M
q : Submodule R M₂
⊢ Submodule.prod p q = map (inl R M M₂) p ⊔ map (inr R M M₂) q
Theorem: CategoryTheory.Limits.le_kernelSubobject
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
A : Subobject X
h : arrow A ≫ f = 0
⊢ kernel.lift f (arrow A) h ≫ kernel.ι f = arrow A
Theorem: List.tail_eq_tailD
File: Std/Data/List/Lemmas.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
l : List α
⊢ tail l = tailD l []
Theorem: Set.ncard_coe_Finset
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_eq_toFinset_card _, Finset.finite_toSet_toFinset]
state_before: α : Type u_1
β : Type ?u.4247
s✝ t : Set α
a b x y : α
f : α → β
s : Finset α
⊢ ncard ↑s = Finset.card s
Theorem: Polynomial.IsSplittingField.of_algEquiv
File: Mathlib/FieldTheory/SplittingField/IsSplittingField.lean

tactic: constructor
state_before: F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ IsSplittingField K L p

tactic: rw [← f.toAlgHom.comp_algebraMap]
state_before: case splits'
F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ Splits (algebraMap K L) p

tactic: exact splits_comp_of_splits _ _ (splits F p)
state_before: case splits'
F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ Splits (RingHom.comp (↑↑f) (algebraMap K F)) p

tactic: rw [← (Algebra.range_top_iff_surjective f.toAlgHom).mpr f.surjective, ← rootSet,
  adjoin_rootSet_eq_range (splits F p), rootSet, adjoin_roots F p]
state_before: case adjoin_roots'
F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ Algebra.adjoin K ↑(Multiset.toFinset (roots (Polynomial.map (algebraMap K L) p))) = ⊤