tasksource/leandojo huggingface dataset:
Theorem: CharP.intCast_eq_intCast
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [eq_comm, ← sub_eq_zero, ← Int.cast_sub, CharP.int_cast_eq_zero_iff R p, Int.modEq_iff_dvd]
state_before: R : Type u_1
inst✝¹ : AddGroupWithOne R
p : ℕ
inst✝ : CharP R p
a b : ℤ
⊢ ↑a = ↑b ↔ a ≡ b [ZMOD ↑p]
Theorem: AList.ext
File: Mathlib/Data/List/AList.lean

tactic: congr
state_before: α : Type u
β : α → Type v
l₁ : List (Sigma β)
h₁ : NodupKeys l₁
l₂ : List (Sigma β)
nodupKeys✝ : NodupKeys l₂
H : { entries := l₁, nodupKeys := h₁ }.entries = { entries := l₂, nodupKeys := nodupKeys✝ }.entries
⊢ { entries := l₁, nodupKeys := h₁ } = { entries := l₂, nodupKeys := nodupKeys✝ }
Theorem: Disjoint.le_of_codisjoint
File: Mathlib/Order/Disjoint.lean

tactic: rw [← @inf_top_eq _ _ _ a, ← @bot_sup_eq _ _ _ c, ← hab.eq_bot, ← hbc.eq_top, sup_inf_right]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b c : α
hab : Disjoint a b
hbc : Codisjoint b c
⊢ a ≤ c

tactic: exact inf_le_inf_right _ le_sup_left
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b c : α
hab : Disjoint a b
hbc : Codisjoint b c
⊢ a ⊓ (b ⊔ c) ≤ (a ⊔ c) ⊓ (b ⊔ c)
Theorem: Nat.Ico_succ_singleton
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Ico_succ_right, Icc_self]
state_before: a b c : ℕ
⊢ Ico a (a + 1) = {a}
Theorem: QuadraticForm.map_add_add_add_map
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: obtain ⟨B, h⟩ := Q.exists_companion
state_before: S : Type ?u.74856
R : Type u_1
R₁ : Type ?u.74862
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
⊢ ↑Q (x + y + z) + (↑Q x + ↑Q y + ↑Q z) = ↑Q (x + y) + ↑Q (y + z) + ↑Q (z + x)

tactic: rw [add_comm z x]
state_before: case intro
S : Type ?u.74856
R : Type u_1
R₁ : Type ?u.74862
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), ↑Q (x + y) = ↑Q x + ↑Q y + BilinForm.bilin B x y
⊢ ↑Q (x + y + z) + (↑Q x + ↑Q y + ↑Q z) = ↑Q (x + y) + ↑Q (y + z) + ↑Q (z + x)

tactic: simp [h]
state_before: case intro
S : Type ?u.74856
R : Type u_1
R₁ : Type ?u.74862
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), ↑Q (x + y) = ↑Q x + ↑Q y + BilinForm.bilin B x y
⊢ ↑Q (x + y + z) + (↑Q x + ↑Q y + ↑Q z) = ↑Q (x + y) + ↑Q (y + z) + ↑Q (x + z)

tactic: abel
state_before: case intro
S : Type ?u.74856
R : Type u_1
R₁ : Type ?u.74862
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), ↑Q (x + y) = ↑Q x + ↑Q y + BilinForm.bilin B x y
⊢ ↑Q x + ↑Q y + BilinForm.bilin B x y + ↑Q z + (BilinForm.bilin B x z + BilinForm.bilin B y z) + (↑Q x + ↑Q y + ↑Q z) =
    ↑Q x + ↑Q y + BilinForm.bilin B x y + (↑Q y + ↑Q z + BilinForm.bilin B y z) + (↑Q x + ↑Q z + BilinForm.bilin B x z)
Theorem: ENNReal.rpow_left_surjective
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp_rw [← rpow_mul, _root_.inv_mul_cancel hx, rpow_one]
state_before: x : ℝ
hx : x ≠ 0
y : ℝ≥0∞
⊢ (fun y => y ^ x) (y ^ x⁻¹) = y
Theorem: Ordinal.mod_one
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [mod_def, div_one, one_mul, sub_self]
state_before: α : Type ?u.261434
β : Type ?u.261437
γ : Type ?u.261440
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ a % 1 = 0
Theorem: Multiset.powersetLen_map
File: Mathlib/Data/Multiset/Powerset.lean

tactic: induction' s using Multiset.induction with t s ih generalizing n
state_before: α : Type u_2
β : Type u_1
f : α → β
n : ℕ
s : Multiset α
⊢ powersetLen n (map f s) = map (map f) (powersetLen n s)

tactic: cases n <;> simp [powersetLen_zero_left, powersetLen_zero_right]
state_before: case empty
α : Type u_2
β : Type u_1
f : α → β
n✝ n : ℕ
⊢ powersetLen n (map f 0) = map (map f) (powersetLen n 0)

tactic: cases n <;> simp [ih, map_comp_cons]
state_before: case cons
α : Type u_2
β : Type u_1
f : α → β
n✝ : ℕ
t : α
s : Multiset α
ih : ∀ (n : ℕ), powersetLen n (map f s) = map (map f) (powersetLen n s)
n : ℕ
⊢ powersetLen n (map f (t ::ₘ s)) = map (map f) (powersetLen n (t ::ₘ s))
Theorem: sdiff_inf_self_left
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_inf, sdiff_self, bot_sup_eq]
state_before: ι : Type ?u.138681
α : Type u_1
β : Type ?u.138687
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
⊢ a \ (a ⊓ b) = a \ b
Theorem: ContinuousOn.integrableOn_compact
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: letI := metrizableSpaceMetric X
state_before: X : Type u_1
Y : Type ?u.711872
E : Type u_2
R : Type ?u.711878
inst✝⁷ : MeasurableSpace X
inst✝⁶ : TopologicalSpace X
inst✝⁵ : MeasurableSpace Y
inst✝⁴ : TopologicalSpace Y
inst✝³ : NormedAddCommGroup E
f : X → E
μ : MeasureTheory.Measure X
s : Set X
inst✝² : OpensMeasurableSpace X
inst✝¹ : IsLocallyFiniteMeasure μ
K : Set X
a b : X
inst✝ : MetrizableSpace X
hK : IsCompact K
hf : ContinuousOn f K
⊢ IntegrableOn f K

tactic: refine' LocallyIntegrableOn.integrableOn_isCompact (fun x hx => _) hK
state_before: X : Type u_1
Y : Type ?u.711872
E : Type u_2
R : Type ?u.711878
inst✝⁷ : MeasurableSpace X
inst✝⁶ : TopologicalSpace X
inst✝⁵ : MeasurableSpace Y
inst✝⁴ : TopologicalSpace Y
inst✝³ : NormedAddCommGroup E
f : X → E
μ : MeasureTheory.Measure X
s : Set X
inst✝² : OpensMeasurableSpace X
inst✝¹ : IsLocallyFiniteMeasure μ
K : Set X
a b : X
inst✝ : MetrizableSpace X
hK : IsCompact K
hf : ContinuousOn f K
this : MetricSpace X := metrizableSpaceMetric X
⊢ IntegrableOn f K

tactic: exact hf.integrableAt_nhdsWithin_of_isSeparable hK.measurableSet hK.isSeparable hx
state_before: X : Type u_1
Y : Type ?u.711872
E : Type u_2
R : Type ?u.711878
inst✝⁷ : MeasurableSpace X
inst✝⁶ : TopologicalSpace X
inst✝⁵ : MeasurableSpace Y
inst✝⁴ : TopologicalSpace Y
inst✝³ : NormedAddCommGroup E
f : X → E
μ : MeasureTheory.Measure X
s : Set X
inst✝² : OpensMeasurableSpace X
inst✝¹ : IsLocallyFiniteMeasure μ
K : Set X
a b : X
inst✝ : MetrizableSpace X
hK : IsCompact K
hf : ContinuousOn f K
this : MetricSpace X := metrizableSpaceMetric X
x : X
hx : x ∈ K
⊢ IntegrableAtFilter f (𝓝[K] x)
Theorem: ContinuousMap.continuous_eval'
File: Mathlib/Topology/CompactOpen.lean

tactic: assumption
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.10621
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace α
x✝ : C(α, β) × α
n : Set β
f : C(α, β)
x : α
hn : n ∈ 𝓝 (↑(f, x).fst (f, x).snd)
v : Set β
vn : v ⊆ n
vo : IsOpen v
fxv : ↑(f, x).fst (f, x).snd ∈ v
this✝² : v ∈ 𝓝 (↑f x)
s : Set α
hs : s ∈ 𝓝 x
sv : s ⊆ ↑f ⁻¹' v
sc : IsCompact s
u : Set α
us : u ⊆ s
uo : IsOpen u
xu : x ∈ u
w : Set (C(α, β) × α) := CompactOpen.gen s v ×ˢ u
this✝¹ : w ⊆ (fun p => ↑p.fst p.snd) ⁻¹' n
this✝ : IsOpen w
this : (f, x) ∈ w
⊢ w ⊆ (fun p => ↑p.fst p.snd) ⁻¹' n

tactic: assumption
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.10621
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace α
x✝ : C(α, β) × α
n : Set β
f : C(α, β)
x : α
hn : n ∈ 𝓝 (↑(f, x).fst (f, x).snd)
v : Set β
vn : v ⊆ n
vo : IsOpen v
fxv : ↑(f, x).fst (f, x).snd ∈ v
this✝² : v ∈ 𝓝 (↑f x)
s : Set α
hs : s ∈ 𝓝 x
sv : s ⊆ ↑f ⁻¹' v
sc : IsCompact s
u : Set α
us : u ⊆ s
uo : IsOpen u
xu : x ∈ u
w : Set (C(α, β) × α) := CompactOpen.gen s v ×ˢ u
this✝¹ : w ⊆ (fun p => ↑p.fst p.snd) ⁻¹' n
this✝ : IsOpen w
this : (f, x) ∈ w
⊢ IsOpen w

tactic: assumption
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.10621
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace α
x✝ : C(α, β) × α
n : Set β
f : C(α, β)
x : α
hn : n ∈ 𝓝 (↑(f, x).fst (f, x).snd)
v : Set β
vn : v ⊆ n
vo : IsOpen v
fxv : ↑(f, x).fst (f, x).snd ∈ v
this✝² : v ∈ 𝓝 (↑f x)
s : Set α
hs : s ∈ 𝓝 x
sv : s ⊆ ↑f ⁻¹' v
sc : IsCompact s
u : Set α
us : u ⊆ s
uo : IsOpen u
xu : x ∈ u
w : Set (C(α, β) × α) := CompactOpen.gen s v ×ˢ u
this✝¹ : w ⊆ (fun p => ↑p.fst p.snd) ⁻¹' n
this✝ : IsOpen w
this : (f, x) ∈ w
⊢ (f, x) ∈ w
Theorem: Complex.sameRay_iff
File: Mathlib/Analysis/Complex/Arg.lean

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: x y : ℂ
⊢ SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ arg x = arg y

tactic: rcases eq_or_ne y 0 with (rfl | hy)
state_before: case inr
x y : ℂ
hx : x ≠ 0
⊢ SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ arg x = arg y

tactic: simp only [hx, hy, false_or_iff, sameRay_iff_norm_smul_eq, arg_eq_arg_iff hx hy]
state_before: case inr.inr
x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ arg x = arg y

tactic: field_simp [hx, hy]
state_before: case inr.inr
x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ‖x‖ • y = ‖y‖ • x ↔ ↑(↑abs y) / ↑(↑abs x) * x = y

tactic: rw [mul_comm, eq_comm]
state_before: case inr.inr
x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ↑(↑abs x) * y = ↑(↑abs y) * x ↔ ↑(↑abs y) * x = y * ↑(↑abs x)

tactic: simp
state_before: case inl
y : ℂ
⊢ SameRay ℝ 0 y ↔ 0 = 0 ∨ y = 0 ∨ arg 0 = arg y

tactic: simp
state_before: case inr.inl
x : ℂ
hx : x ≠ 0
⊢ SameRay ℝ x 0 ↔ x = 0 ∨ 0 = 0 ∨ arg x = arg 0
Theorem: MeasureTheory.Lp.lipschitzWith_pos_part
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [Real.dist_eq, abs_max_sub_max_le_abs]
state_before: α : Type ?u.8088288
E : Type ?u.8088291
F : Type ?u.8088294
G : Type ?u.8088297
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
x y : ℝ
⊢ dist (max x 0) (max y 0) ≤ ↑1 * dist x y
Theorem: Nat.odd_of_mod_four_eq_one
File: Mathlib/Data/Nat/ModEq.lean

tactic: simpa [ModEq, show 2 * 2 = 4 by norm_num] using @ModEq.of_mul_left 2 n 1 2
state_before: m n✝ a b c d n : ℕ
⊢ n % 4 = 1 → n % 2 = 1

tactic: norm_num
state_before: m n✝ a b c d n : ℕ
⊢ 2 * 2 = 4
Theorem: Nat.even_mul_succ_self
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [even_mul, even_add_one]
state_before: m n✝ n : ℕ
⊢ Even (n * (n + 1))

tactic: exact em _
state_before: m n✝ n : ℕ
⊢ Even n ∨ ¬Even n
Theorem: IsLocalization.AtPrime.mk'_mem_maximal_iff
File: Mathlib/RingTheory/Localization/AtPrime.lean

tactic: simpa only [LocalRing.mem_maximalIdeal, mem_nonunits_iff, Classical.not_not] using
  isUnit_mk'_iff S I x y
state_before: R : Type u_1
inst✝⁶ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
P : Type ?u.75214
inst✝³ : CommSemiring P
A : Type ?u.75220
inst✝² : CommRing A
inst✝¹ : IsDomain A
I : Ideal R
hI : Ideal.IsPrime I
inst✝ : IsLocalization.AtPrime S I
x : R
y : { x // x ∈ Ideal.primeCompl I }
h : optParam (LocalRing S) (_ : LocalRing S)
⊢ ¬mk' S x y ∈ LocalRing.maximalIdeal S ↔ ¬x ∈ I
Theorem: inv_pow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [pow_zero, pow_zero, inv_one]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a✝ b a : α
⊢ a⁻¹ ^ 0 = (a ^ 0)⁻¹

tactic: rw [pow_succ', pow_succ, inv_pow _ n, mul_inv_rev]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a✝ b a : α
n : ℕ
⊢ a⁻¹ ^ (n + 1) = (a ^ (n + 1))⁻¹
Theorem: LocalEquiv.EqOnSource.symm'
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: refine' ⟨target_eq h, eqOn_of_leftInvOn_of_rightInvOn e.leftInvOn _ _⟩ <;>
  simp only [symm_source, target_eq h, source_eq h, e'.symm_mapsTo]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.56162
δ : Type ?u.56165
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
h : e ≈ e'
⊢ LocalEquiv.symm e ≈ LocalEquiv.symm e'

tactic: exact e'.rightInvOn.congr_right e'.symm_mapsTo (source_eq h ▸ h.eqOn.symm)
state_before: case refine'_1
α : Type u_1
β : Type u_2
γ : Type ?u.56162
δ : Type ?u.56165
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
h : e ≈ e'
⊢ RightInvOn (↑(LocalEquiv.symm e')) (↑e) e'.target
Theorem: innerDualCone_univ
File: Mathlib/Analysis/Convex/Cone/Dual.lean

tactic: suffices ∀ x : H, x ∈ (univ : Set H).innerDualCone → x = 0 by
  apply SetLike.coe_injective
  exact eq_singleton_iff_unique_mem.mpr ⟨fun x _ => (inner_zero_right _).ge, this⟩
state_before: 𝕜 : Type ?u.5561
E : Type ?u.5564
F : Type ?u.5567
G : Type ?u.5570
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ innerDualCone univ = 0

tactic: exact fun x hx => by simpa [← real_inner_self_nonpos] using hx (-x) (mem_univ _)
state_before: 𝕜 : Type ?u.5561
E : Type ?u.5564
F : Type ?u.5567
G : Type ?u.5570
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ ∀ (x : H), x ∈ innerDualCone univ → x = 0

tactic: apply SetLike.coe_injective
state_before: 𝕜 : Type ?u.5561
E : Type ?u.5564
F : Type ?u.5567
G : Type ?u.5570
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
this : ∀ (x : H), x ∈ innerDualCone univ → x = 0
⊢ innerDualCone univ = 0

tactic: exact eq_singleton_iff_unique_mem.mpr ⟨fun x _ => (inner_zero_right _).ge, this⟩
state_before: case a
𝕜 : Type ?u.5561
E : Type ?u.5564
F : Type ?u.5567
G : Type ?u.5570
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
this : ∀ (x : H), x ∈ innerDualCone univ → x = 0
⊢ ↑(innerDualCone univ) = ↑0

tactic: simpa [← real_inner_self_nonpos] using hx (-x) (mem_univ _)
state_before: 𝕜 : Type ?u.5561
E : Type ?u.5564
F : Type ?u.5567
G : Type ?u.5570
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : H
hx : x ∈ innerDualCone univ
⊢ x = 0
Theorem: Bool.or_false
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b || false) = b
Theorem: Polynomial.IsWeaklyEisensteinAt.pow_natDegree_le_of_aeval_zero_of_monic_mem_map
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

tactic: suffices x ^ (f.map (algebraMap R S)).natDegree ∈ 𝓟.map (algebraMap R S) by
  intro i hi
  obtain ⟨k, hk⟩ := exists_add_of_le hi
  rw [hk, pow_add]
  refine' mul_mem_right _ _ this
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : ↑(aeval x) f = 0
hmo : Monic f
⊢ ∀ (i : ℕ), natDegree (Polynomial.map (algebraMap R S) f) ≤ i → x ^ i ∈ Ideal.map (algebraMap R S) 𝓟

tactic: rw [aeval_def, eval₂_eq_eval_map, ← IsRoot.def] at hx
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : ↑(aeval x) f = 0
hmo : Monic f
⊢ x ^ natDegree (Polynomial.map (algebraMap R S) f) ∈ Ideal.map (algebraMap R S) 𝓟

tactic: refine' pow_natDegree_le_of_root_of_monic_mem (hf.map _) hx (hmo.map _) _ rfl.le
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : IsRoot (Polynomial.map (algebraMap R S) f) x
hmo : Monic f
⊢ x ^ natDegree (Polynomial.map (algebraMap R S) f) ∈ Ideal.map (algebraMap R S) 𝓟

tactic: intro i hi
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : ↑(aeval x) f = 0
hmo : Monic f
this : x ^ natDegree (Polynomial.map (algebraMap R S) f) ∈ Ideal.map (algebraMap R S) 𝓟
⊢ ∀ (i : ℕ), natDegree (Polynomial.map (algebraMap R S) f) ≤ i → x ^ i ∈ Ideal.map (algebraMap R S) 𝓟

tactic: obtain ⟨k, hk⟩ := exists_add_of_le hi
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : ↑(aeval x) f = 0
hmo : Monic f
this : x ^ natDegree (Polynomial.map (algebraMap R S) f) ∈ Ideal.map (algebraMap R S) 𝓟
i : ℕ
hi : natDegree (Polynomial.map (algebraMap R S) f) ≤ i
⊢ x ^ i ∈ Ideal.map (algebraMap R S) 𝓟

tactic: rw [hk, pow_add]
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : ↑(aeval x) f = 0
hmo : Monic f
this : x ^ natDegree (Polynomial.map (algebraMap R S) f) ∈ Ideal.map (algebraMap R S) 𝓟
i : ℕ
hi : natDegree (Polynomial.map (algebraMap R S) f) ≤ i
k : ℕ
hk : i = natDegree (Polynomial.map (algebraMap R S) f) + k
⊢ x ^ i ∈ Ideal.map (algebraMap R S) 𝓟

tactic: refine' mul_mem_right _ _ this
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : ↑(aeval x) f = 0
hmo : Monic f
this : x ^ natDegree (Polynomial.map (algebraMap R S) f) ∈ Ideal.map (algebraMap R S) 𝓟
i : ℕ
hi : natDegree (Polynomial.map (algebraMap R S) f) ≤ i
k : ℕ
hk : i = natDegree (Polynomial.map (algebraMap R S) f) + k
⊢ x ^ natDegree (Polynomial.map (algebraMap R S) f) * x ^ k ∈ Ideal.map (algebraMap R S) 𝓟
Theorem: Nat.coprime_sub_mul_floor_rat_div_of_coprime
File: Mathlib/Data/Rat/Floor.lean

tactic: have : (n : ℤ) % d = n - d * ⌊(n : ℚ) / d⌋ := Int.mod_nat_eq_sub_mul_floor_rat_div
state_before: n d : ℕ
n_coprime_d : coprime n d
⊢ coprime (natAbs (↑n - ↑d * ⌊↑n / ↑d⌋)) d

tactic: rw [← this]
state_before: n d : ℕ
n_coprime_d : coprime n d
this : ↑n % ↑d = ↑n - ↑d * ⌊↑n / ↑d⌋
⊢ coprime (natAbs (↑n - ↑d * ⌊↑n / ↑d⌋)) d

tactic: have : d.coprime n := n_coprime_d.symm
state_before: n d : ℕ
n_coprime_d : coprime n d
this : ↑n % ↑d = ↑n - ↑d * ⌊↑n / ↑d⌋
⊢ coprime (natAbs (↑n % ↑d)) d

tactic: rwa [Nat.coprime, Nat.gcd_rec] at this
state_before: n d : ℕ
n_coprime_d : coprime n d
this✝ : ↑n % ↑d = ↑n - ↑d * ⌊↑n / ↑d⌋
this : coprime d n
⊢ coprime (natAbs (↑n % ↑d)) d
Theorem: min_div_div_right'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simpa only [div_eq_mul_inv] using min_mul_mul_right a b c⁻¹
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ min (a / c) (b / c) = min a b / c
Theorem: subsingleton_iff
File: Mathlib/Logic/Nontrivial.lean

tactic: intro h
state_before: α : Type u_1
β : Type ?u.2650
⊢ Subsingleton α → ∀ (x y : α), x = y

tactic: exact Subsingleton.elim
state_before: α : Type u_1
β : Type ?u.2650
h : Subsingleton α
⊢ ∀ (x y : α), x = y
Theorem: EReal.coe_ennreal_top_mul
File: Mathlib/Data/Real/EReal.lean

tactic: rcases eq_or_ne x 0 with (rfl | h0)
state_before: x : ℝ≥0
⊢ ↑(⊤ * ↑x) = ⊤ * ↑↑x

tactic: simp
state_before: case inl

⊢ ↑(⊤ * ↑0) = ⊤ * ↑↑0

tactic: rw [ENNReal.top_mul (ENNReal.coe_ne_zero.2 h0)]
state_before: case inr
x : ℝ≥0
h0 : x ≠ 0
⊢ ↑(⊤ * ↑x) = ⊤ * ↑↑x

tactic: exact Eq.symm <| if_pos <| NNReal.coe_pos.2 h0.bot_lt
state_before: case inr
x : ℝ≥0
h0 : x ≠ 0
⊢ ↑⊤ = ⊤ * ↑↑x
Theorem: Filter.pi_inf_principal_pi_neBot
File: Mathlib/Order/Filter/Pi.lean

tactic: simp [neBot_iff]
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f i)
I : Set ι
⊢ NeBot (pi f ⊓ 𝓟 (Set.pi I s)) ↔ ∀ (i : ι), i ∈ I → NeBot (f i ⊓ 𝓟 (s i))
Theorem: hammingDist_triangle_right
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [hammingDist_comm y]
state_before: α : Type ?u.6007
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.6039
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist x z + hammingDist y z

tactic: exact hammingDist_triangle _ _ _
state_before: α : Type ?u.6007
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.6039
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist x z + hammingDist z y
Theorem: SimpleGraph.fromEdgeSet_edgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext (v w)
state_before: ι : Sort ?u.82485
𝕜 : Type ?u.82488
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ fromEdgeSet (edgeSet G) = G

tactic: exact ⟨fun h => h.1, fun h => ⟨h, G.ne_of_adj h⟩⟩
state_before: case Adj.h.h.a
ι : Sort ?u.82485
𝕜 : Type ?u.82488
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ Adj (fromEdgeSet (edgeSet G)) v w ↔ Adj G v w
Theorem: TopologicalSpace.Opens.isCoatom_iff
File: Mathlib/Topology/Sets/Closeds.lean

tactic: rw [← s.compl_compl, ← isAtom_dual_iff_isCoatom]
state_before: ι : Type ?u.28195
α : Type u_1
β : Type ?u.28201
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsCoatom s ↔ ∃ x, s = Closeds.compl (Closeds.singleton x)

tactic: change IsAtom (Closeds.complOrderIso α s.compl) ↔ _
state_before: ι : Type ?u.28195
α : Type u_1
β : Type ?u.28201
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsAtom (↑toDual (Closeds.compl (compl s))) ↔ ∃ x, Closeds.compl (compl s) = Closeds.compl (Closeds.singleton x)

tactic: simp only [(Closeds.complOrderIso α).isAtom_iff, Closeds.isAtom_iff,
  Closeds.compl_bijective.injective.eq_iff]
state_before: ι : Type ?u.28195
α : Type u_1
β : Type ?u.28201
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsAtom (↑(Closeds.complOrderIso α) (compl s)) ↔ ∃ x, Closeds.compl (compl s) = Closeds.compl (Closeds.singleton x)
Theorem: Finset.Icc_eq_image_powerset
File: Mathlib/Data/Finset/Interval.lean

tactic: ext u
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ Icc s t = image ((fun x x_1 => x ∪ x_1) s) (powerset (t \ s))

tactic: simp_rw [mem_Icc, mem_image, mem_powerset]
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ u ∈ Icc s t ↔ u ∈ image ((fun x x_1 => x ∪ x_1) s) (powerset (t \ s))

tactic: constructor
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ s ≤ u ∧ u ≤ t ↔ ∃ a, a ⊆ t \ s ∧ s ∪ a = u

tactic: rintro ⟨hs, ht⟩
state_before: case a.mp
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ s ≤ u ∧ u ≤ t → ∃ a, a ⊆ t \ s ∧ s ∪ a = u

tactic: exact ⟨u \ s, sdiff_le_sdiff_right ht, sup_sdiff_cancel_right hs⟩
state_before: case a.mp.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
hs : s ≤ u
ht : u ≤ t
⊢ ∃ a, a ⊆ t \ s ∧ s ∪ a = u

tactic: rintro ⟨v, hv, rfl⟩
state_before: case a.mpr
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
⊢ (∃ a, a ⊆ t \ s ∧ s ∪ a = u) → s ≤ u ∧ u ≤ t

tactic: exact ⟨le_sup_left, union_subset h <| hv.trans <| sdiff_subset _ _⟩
state_before: case a.mpr.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
v : Finset α
hv : v ⊆ t \ s
⊢ s ≤ s ∪ v ∧ s ∪ v ≤ t