tasksource/leandojo huggingface dataset:
Theorem: iteratedFDeriv_succ_eq_comp_right
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: ext m
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ iteratedFDeriv 𝕜 (n + 1) f x =
    (↑(continuousMultilinearCurryRightEquiv' 𝕜 n E F) ∘ iteratedFDeriv 𝕜 n fun y => fderiv 𝕜 f y) x

tactic: rw [iteratedFDeriv_succ_apply_right]
state_before: case H
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
m : Fin (n + 1) → E
⊢ ↑(iteratedFDeriv 𝕜 (n + 1) f x) m =
    ↑((↑(continuousMultilinearCurryRightEquiv' 𝕜 n E F) ∘ iteratedFDeriv 𝕜 n fun y => fderiv 𝕜 f y) x) m

tactic: rfl
state_before: case H
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
m : Fin (n + 1) → E
⊢ ↑(↑(iteratedFDeriv 𝕜 n (fun y => fderiv 𝕜 f y) x) (init m)) (m (last n)) =
    ↑((↑(continuousMultilinearCurryRightEquiv' 𝕜 n E F) ∘ iteratedFDeriv 𝕜 n fun y => fderiv 𝕜 f y) x) m
Theorem: Language.nil_mem_kstar
File: Mathlib/Computability/Language.lean

tactic: contradiction
state_before: α : Type u_1
β : Type ?u.36899
γ : Type ?u.36902
l✝ m : Language α
a b x : List α
l : Language α
x✝ : List α
h : x✝ ∈ []
⊢ x✝ ∈ l
Theorem: Ring.exists_not_isUnit_of_not_isField
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: have : ¬_ := fun h => hf ⟨exists_pair_ne R, mul_comm, h⟩
state_before: α : Type u
β : Type v
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hf : ¬IsField R
⊢ ∃ x _hx, ¬IsUnit x

tactic: simp_rw [isUnit_iff_exists_inv]
state_before: α : Type u
β : Type v
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hf : ¬IsField R
this : ¬∀ {a : R}, a ≠ 0 → ∃ b, a * b = 1
⊢ ∃ x _hx, ¬IsUnit x

tactic: push_neg  at this⊢
state_before: α : Type u
β : Type v
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hf : ¬IsField R
this : ¬∀ {a : R}, a ≠ 0 → ∃ b, a * b = 1
⊢ ∃ x h, ¬∃ b, x * b = 1

tactic: obtain ⟨x, hx, not_unit⟩ := this
state_before: α : Type u
β : Type v
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hf : ¬IsField R
this : Exists fun {a} => a ≠ 0 ∧ ∀ (b : R), a * b ≠ 1
⊢ ∃ x h, ∀ (b : R), x * b ≠ 1

tactic: exact ⟨x, hx, not_unit⟩
state_before: case intro.intro
α : Type u
β : Type v
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hf : ¬IsField R
x : R
hx : x ≠ 0
not_unit : ∀ (b : R), x * b ≠ 1
⊢ ∃ x h, ∀ (b : R), x * b ≠ 1
Theorem: IsPreconnected.constant_of_mapsTo
File: Mathlib/Topology/Connected.lean

tactic: let F : S → T := hTm.restrict f S T
state_before: α : Type u
β : Type v
ι : Type ?u.149420
π : ι → Type ?u.149425
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
S : Set α
hS : IsPreconnected S
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hc : ContinuousOn f S
hTm : MapsTo f S T
x y : α
hx : x ∈ S
hy : y ∈ S
⊢ f x = f y

tactic: suffices F ⟨x, hx⟩ = F ⟨y, hy⟩ by rwa [← Subtype.coe_inj] at this
state_before: α : Type u
β : Type v
ι : Type ?u.149420
π : ι → Type ?u.149425
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
S : Set α
hS : IsPreconnected S
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hc : ContinuousOn f S
hTm : MapsTo f S T
x y : α
hx : x ∈ S
hy : y ∈ S
F : ↑S → ↑T := MapsTo.restrict f S T hTm
⊢ f x = f y

tactic: exact (isPreconnected_iff_preconnectedSpace.mp hS).constant (hc.restrict_mapsTo _)
state_before: α : Type u
β : Type v
ι : Type ?u.149420
π : ι → Type ?u.149425
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
S : Set α
hS : IsPreconnected S
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hc : ContinuousOn f S
hTm : MapsTo f S T
x y : α
hx : x ∈ S
hy : y ∈ S
F : ↑S → ↑T := MapsTo.restrict f S T hTm
⊢ F { val := x, property := hx } = F { val := y, property := hy }

tactic: rwa [← Subtype.coe_inj] at this
state_before: α : Type u
β : Type v
ι : Type ?u.149420
π : ι → Type ?u.149425
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
S : Set α
hS : IsPreconnected S
T : Set β
inst✝ : DiscreteTopology ↑T
f : α → β
hc : ContinuousOn f S
hTm : MapsTo f S T
x y : α
hx : x ∈ S
hy : y ∈ S
F : ↑S → ↑T := MapsTo.restrict f S T hTm
this : F { val := x, property := hx } = F { val := y, property := hy }
⊢ f x = f y
Theorem: Pell.xy_modEq_of_modEq
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: constructor <;> rfl
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ xn a1 0 ≡ xn b1 0 [MOD c] ∧ yn a1 0 ≡ yn b1 0 [MOD c]

tactic: simp
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ xn a1 1 ≡ xn b1 1 [MOD c] ∧ yn a1 1 ≡ yn b1 1 [MOD c]

tactic: exact ⟨h, ModEq.refl 1⟩
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ a ≡ b [MOD c] ∧ 1 ≡ 1 [MOD c]

tactic: rw [xn_succ_succ a1, xn_succ_succ b1]
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ xn a1 (n + 2) + xn a1 n ≡ xn b1 (n + 2) + xn b1 n [MOD c]

tactic: exact (h.mul_left _).mul (xy_modEq_of_modEq _ _ h (n + 1)).left
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ 2 * a * xn a1 (n + 1) ≡ 2 * b * xn b1 (n + 1) [MOD c]

tactic: rw [yn_succ_succ a1, yn_succ_succ b1]
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ yn a1 (n + 2) + yn (_ : 1 < a) n ≡ yn b1 (n + 2) + yn (_ : 1 < b) n [MOD c]

tactic: exact (h.mul_left _).mul (xy_modEq_of_modEq _ _ h (n + 1)).right
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ 2 * a * yn a1 (n + 1) ≡ 2 * b * yn b1 (n + 1) [MOD c]
Theorem: exists_bounded_mem_Icc_of_closed_of_le
File: Mathlib/Topology/UrysohnsBounded.lean

tactic: simp [hfs hx]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (↑f) 0 s
hft : EqOn (↑f) 1 t
hf01 : ∀ (x : X), ↑f x ∈ Icc 0 1
x : X
hx : x ∈ s
⊢ ↑(BoundedContinuousFunction.const X a + (b - a) • f) x = Function.const X a x

tactic: simp [hft hx]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (↑f) 0 s
hft : EqOn (↑f) 1 t
hf01 : ∀ (x : X), ↑f x ∈ Icc 0 1
x : X
hx : x ∈ t
⊢ ↑(BoundedContinuousFunction.const X a + (b - a) • f) x = Function.const X b x

tactic: dsimp
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (↑f) 0 s
hft : EqOn (↑f) 1 t
hf01 : ∀ (x : X), ↑f x ∈ Icc 0 1
x : X
⊢ a ≤ ↑(BoundedContinuousFunction.const X a + (b - a) • f) x

tactic: nlinarith [(hf01 x).1]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (↑f) 0 s
hft : EqOn (↑f) 1 t
hf01 : ∀ (x : X), ↑f x ∈ Icc 0 1
x : X
⊢ a ≤ a + (b - a) * ↑f x

tactic: dsimp
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (↑f) 0 s
hft : EqOn (↑f) 1 t
hf01 : ∀ (x : X), ↑f x ∈ Icc 0 1
x : X
⊢ ↑(BoundedContinuousFunction.const X a + (b - a) • f) x ≤ b

tactic: nlinarith [(hf01 x).2]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
a b : ℝ
hle : a ≤ b
f : X →ᵇ ℝ
hfs : EqOn (↑f) 0 s
hft : EqOn (↑f) 1 t
hf01 : ∀ (x : X), ↑f x ∈ Icc 0 1
x : X
⊢ a + (b - a) * ↑f x ≤ b
Theorem: Basis.toMatrix_reindex
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: ext
state_before: ι : Type u_1
ι' : Type u_4
κ : Type ?u.637514
κ' : Type ?u.637517
R : Type u_2
M : Type u_3
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type ?u.637710
M₂ : Type ?u.637713
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type ?u.638458
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
⊢ toMatrix (reindex b e) v = submatrix (toMatrix b v) (↑e.symm) _root_.id

tactic: simp only [Basis.toMatrix_apply, Basis.repr_reindex, Matrix.submatrix_apply, id.def,
  Finsupp.mapDomain_equiv_apply]
state_before: case a.h
ι : Type u_1
ι' : Type u_4
κ : Type ?u.637514
κ' : Type ?u.637517
R : Type u_2
M : Type u_3
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type ?u.637710
M₂ : Type ?u.637713
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type ?u.638458
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
i✝ x✝ : ι'
⊢ toMatrix (reindex b e) v i✝ x✝ = submatrix (toMatrix b v) (↑e.symm) _root_.id i✝ x✝
Theorem: Ideal.maximal_of_no_maximal
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: by_contra hnonmax
state_before: α : Type u
β : Type v
inst✝¹ : Semiring α
I : Ideal α
a b : α
R : Type u
inst✝ : Semiring R
P : Ideal R
hmax : ∀ (m : Ideal R), P < m → ¬IsMaximal m
J : Ideal R
hPJ : P < J
⊢ J = ⊤

tactic: rcases exists_le_maximal J hnonmax with ⟨M, hM1, hM2⟩
state_before: α : Type u
β : Type v
inst✝¹ : Semiring α
I : Ideal α
a b : α
R : Type u
inst✝ : Semiring R
P : Ideal R
hmax : ∀ (m : Ideal R), P < m → ¬IsMaximal m
J : Ideal R
hPJ : P < J
hnonmax : ¬J = ⊤
⊢ False

tactic: exact hmax M (lt_of_lt_of_le hPJ hM2) hM1
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : Semiring α
I : Ideal α
a b : α
R : Type u
inst✝ : Semiring R
P : Ideal R
hmax : ∀ (m : Ideal R), P < m → ¬IsMaximal m
J : Ideal R
hPJ : P < J
hnonmax : ¬J = ⊤
M : Ideal R
hM1 : IsMaximal M
hM2 : J ≤ M
⊢ False
Theorem: Inducing.isOpen_iff
File: Mathlib/Topology/Maps.lean

tactic: rw [hf.induced, isOpen_induced_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.6214
δ : Type ?u.6217
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : Inducing f
s : Set α
⊢ IsOpen s ↔ ∃ t, IsOpen t ∧ f ⁻¹' t = s
Theorem: IsCoprime.prod_right
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: simpa only [isCoprime_comm] using IsCoprime.prod_left (R := R)
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
⊢ (∀ (i : I), i ∈ t → IsCoprime x (s i)) → IsCoprime x (∏ i in t, s i)
Theorem: Polynomial.reflect_add
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: ext
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f g : R[X]
N : ℕ
⊢ reflect N (f + g) = reflect N f + reflect N g

tactic: simp only [coeff_add, coeff_reflect]
state_before: case a
R : Type u_1
inst✝ : Semiring R
f✝ f g : R[X]
N n✝ : ℕ
⊢ coeff (reflect N (f + g)) n✝ = coeff (reflect N f + reflect N g) n✝
Theorem: ENNReal.top_mul'
File: Mathlib/Data/Real/ENNReal.lean

tactic: convert WithTop.top_mul' a
state_before: α : Type ?u.84274
β : Type ?u.84277
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⊤ * a = if a = 0 then 0 else ⊤
Theorem: Ioo_subset_closure_interior
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [interior_Ioo, subset_closure]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
a b : α
⊢ Ioo a b ⊆ closure (interior (Ioo a b))
Theorem: invOf_neg
File: Mathlib/Algebra/Invertible.lean

tactic: simp
state_before: α : Type u
inst✝³ : Monoid α
inst✝² : HasDistribNeg α
a : α
inst✝¹ : Invertible a
inst✝ : Invertible (-a)
⊢ -a * -⅟a = 1
Theorem: Filter.Germ.coe_lt
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, EventuallyLE]
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : Preorder β
f g : α → β
⊢ ↑f < ↑g ↔ ∀* (x : α), f x < g x
Theorem: Set.ordConnectedProj_eq
File: Mathlib/Data/Set/Intervals/OrdConnectedComponent.lean

tactic: constructor <;> intro h
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
⊢ ordConnectedProj s x = ordConnectedProj s y ↔ [[↑x, ↑y]] ⊆ s

tactic: rw [← mem_ordConnectedComponent, ← ordConnectedComponent_ordConnectedProj, h,
  ordConnectedComponent_ordConnectedProj, self_mem_ordConnectedComponent]
state_before: case mp
α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
h : ordConnectedProj s x = ordConnectedProj s y
⊢ [[↑x, ↑y]] ⊆ s

tactic: exact y.2
state_before: case mp
α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
h : ordConnectedProj s x = ordConnectedProj s y
⊢ ↑y ∈ s

tactic: simp only [ordConnectedProj, ordConnectedComponent_eq h]
state_before: case mpr
α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
h : [[↑x, ↑y]] ⊆ s
⊢ ordConnectedProj s x = ordConnectedProj s y
Theorem: Finset.powersetLen_self
File: Mathlib/Data/Finset/Powerset.lean

tactic: ext
state_before: α : Type u_1
s✝ t s : Finset α
⊢ powersetLen (card s) s = {s}

tactic: rw [mem_powersetLen, mem_singleton]
state_before: case a
α : Type u_1
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetLen (card s) s ↔ a✝ ∈ {s}

tactic: constructor
state_before: case a
α : Type u_1
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ card a✝ = card s ↔ a✝ = s

tactic: exact fun ⟨hs, hc⟩ => eq_of_subset_of_card_le hs hc.ge
state_before: case a.mp
α : Type u_1
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ card a✝ = card s → a✝ = s

tactic: rintro rfl
state_before: case a.mpr
α : Type u_1
s✝ t s a✝ : Finset α
⊢ a✝ = s → a✝ ⊆ s ∧ card a✝ = card s

tactic: simp
state_before: case a.mpr
α : Type u_1
s t a✝ : Finset α
⊢ a✝ ⊆ a✝ ∧ card a✝ = card a✝
Theorem: Ideal.IsDedekindDomain.ramificationIdx_ne_zero
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: have hP0 : P ≠ ⊥ := by
  rintro rfl
  have := le_bot_iff.mp le
  contradiction
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
le : map f p ≤ P
⊢ ramificationIdx f p P ≠ 0

tactic: have hPirr := (Ideal.prime_of_isPrime hP0 hP).irreducible
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
le : map f p ≤ P
hP0 : P ≠ ⊥
⊢ ramificationIdx f p P ≠ 0

tactic: rw [IsDedekindDomain.ramificationIdx_eq_normalizedFactors_count hp0 hP hP0]
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
le : map f p ≤ P
hP0 : P ≠ ⊥
hPirr : Irreducible P
⊢ ramificationIdx f p P ≠ 0

tactic: obtain ⟨P', hP', P'_eq⟩ :=
  exists_mem_normalizedFactors_of_dvd hp0 hPirr (Ideal.dvd_iff_le.mpr le)
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
le : map f p ≤ P
hP0 : P ≠ ⊥
hPirr : Irreducible P
⊢ Multiset.count P (normalizedFactors (map f p)) ≠ 0

tactic: rwa [Multiset.count_ne_zero, associated_iff_eq.mp P'_eq]
state_before: case intro.intro
R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
le : map f p ≤ P
hP0 : P ≠ ⊥
hPirr : Irreducible P
P' : Ideal S
hP' : P' ∈ normalizedFactors (map f p)
P'_eq : Associated P P'
⊢ Multiset.count P (normalizedFactors (map f p)) ≠ 0

tactic: rintro rfl
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
le : map f p ≤ P
⊢ P ≠ ⊥

tactic: have := le_bot_iff.mp le
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime ⊥
le : map f p ≤ ⊥
⊢ False

tactic: contradiction
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime ⊥
le : map f p ≤ ⊥
this : map f p = ⊥
⊢ False
Theorem: FirstOrder.Language.BoundedFormula.semanticallyEquivalent_not_not
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ ψ : BoundedFormula L α n
M : Theory.ModelType T
v : α → ↑M
xs : Fin n → ↑M
⊢ Realize (φ ⇔ ∼∼φ) v xs
Theorem: Asymptotics.IsBigO.trans_tendsto_norm_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: rcases huv.exists_pos with ⟨c, hc, hcuv⟩
state_before: 𝕜 : Type u_2
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_1
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
⊢ Tendsto (fun x => ‖v x‖) l atTop

tactic: rw [IsBigOWith] at hcuv
state_before: case intro.intro
𝕜 : Type u_2
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_1
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : 0 < c
hcuv : IsBigOWith c l u v
⊢ Tendsto (fun x => ‖v x‖) l atTop

tactic: convert Tendsto.atTop_div_const hc (tendsto_atTop_mono' l hcuv hu)
state_before: case intro.intro
𝕜 : Type u_2
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_1
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : 0 < c
hcuv : ∀ᶠ (x : α) in l, ‖u x‖ ≤ c * ‖v x‖
⊢ Tendsto (fun x => ‖v x‖) l atTop

tactic: rw [mul_div_cancel_left _ hc.ne.symm]
state_before: case h.e'_3.h
𝕜 : Type u_2
inst✝ : NormedLinearOrderedField 𝕜
α : Type u_1
u v : α → 𝕜
l : Filter α
huv : u =O[l] v
hu : Tendsto (fun x => ‖u x‖) l atTop
c : ℝ
hc : 0 < c
hcuv : ∀ᶠ (x : α) in l, ‖u x‖ ≤ c * ‖v x‖
x✝ : α
⊢ ‖v x✝‖ = c * ‖v x✝‖ / c
Theorem: IsOpen.union
File: Mathlib/Topology/Basic.lean

tactic: rw [union_eq_iUnion]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (s₁ ∪ s₂)

tactic: exact isOpen_iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (⋃ (b : Bool), bif b then s₁ else s₂)
Theorem: SupBotHom.cancel_left
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.109835
ι : Type ?u.109838
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.109850
inst✝⁷ : Sup α
inst✝⁶ : Bot α
inst✝⁵ : Sup β
inst✝⁴ : Bot β
inst✝³ : Sup γ
inst✝² : Bot γ
inst✝¹ : Sup δ
inst✝ : Bot δ
g : SupBotHom β γ
f₁ f₂ : SupBotHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: List.infix_append'
File: Std/Data/List/Lemmas.lean

tactic: rw [← List.append_assoc]
state_before: α : Type u_1
l₁ l₂ l₃ : List α
⊢ l₂ <:+: l₁ ++ (l₂ ++ l₃)

tactic: apply infix_append
state_before: α : Type u_1
l₁ l₂ l₃ : List α
⊢ l₂ <:+: l₁ ++ l₂ ++ l₃
Theorem: Nat.ArithmeticFunction.pow_apply
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: cases k
state_before: R : Type ?u.509735
k n : ℕ
⊢ ↑(pow k) n = if k = 0 ∧ n = 0 then 0 else n ^ k

tactic: rename_i k
state_before: case succ
R : Type ?u.509735
n n✝ : ℕ
⊢ ↑(pow (succ n✝)) n = if succ n✝ = 0 ∧ n = 0 then 0 else n ^ succ n✝

tactic: simp [pow, (ne_of_lt (Nat.succ_pos k)).symm]
state_before: case succ
R : Type ?u.509735
n k : ℕ
⊢ ↑(pow (succ k)) n = if succ k = 0 ∧ n = 0 then 0 else n ^ succ k

tactic: simp [pow]
state_before: case zero
R : Type ?u.509735
n : ℕ
⊢ ↑(pow Nat.zero) n = if Nat.zero = 0 ∧ n = 0 then 0 else n ^ Nat.zero
Theorem: SimpleGraph.Walk.IsPath.of_append_left
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [isPath_def, support_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
⊢ IsPath (append p q) → IsPath p

tactic: exact List.Nodup.of_append_left
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
⊢ List.Nodup (support p ++ List.tail (support q)) → List.Nodup (support p)
Theorem: Nat.exists_mul_self
File: Mathlib/Data/Nat/Sqrt.lean

tactic: rw [← hn, sqrt_eq]
state_before: x : ℕ
x✝ : ∃ n, n * n = x
n : ℕ
hn : n * n = x
⊢ sqrt x * sqrt x = x
Theorem: inf_sdiff_assoc
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [inf_assoc]
state_before: α : Type u
β : Type ?u.38191
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y ⊓ z ⊔ x ⊓ y \ z = x ⊓ (y ⊓ z) ⊔ x ⊓ y \ z

tactic: rw [sup_inf_sdiff]
state_before: α : Type u
β : Type ?u.38191
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ (y ⊓ z ⊔ y \ z) = x ⊓ y

tactic: ac_rfl
state_before: α : Type u
β : Type ?u.38191
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y ⊓ z ⊓ (x ⊓ y \ z) = x ⊓ x ⊓ (y ⊓ z ⊓ y \ z)

tactic: rw [inf_inf_sdiff, inf_bot_eq]
state_before: α : Type u
β : Type ?u.38191
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ x ⊓ (y ⊓ z ⊓ y \ z) = ⊥
Theorem: Finset.image_mul_left
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp
state_before: F : Type ?u.616170
α : Type u_1
β : Type ?u.616176
γ : Type ?u.616179
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ ↑(image (fun b => a * b) t) =
    ↑(preimage t (fun b => a⁻¹ * b) (_ : Set.InjOn ((fun x x_1 => x * x_1) a⁻¹) ((fun b => a⁻¹ * b) ⁻¹' ↑t)))
Theorem: Multiset.noncommFold_coe
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: simp [noncommFold]
state_before: F : Type ?u.3706
ι : Type ?u.3709
α : Type u_1
β : Type ?u.3715
γ : Type ?u.3718
f : α → β → β
op : α → α → α
assoc : IsAssociative α op
l : List α
comm : Set.Pairwise {x | x ∈ ↑l} fun x y => op x y = op y x
a : α
⊢ noncommFold op (↑l) comm a = List.foldr op a l
Theorem: Fintype.IsSimpleOrder.univ
File: Mathlib/Order/Atoms/Finite.lean

tactic: change Finset.map _ (Finset.univ : Finset Bool) = _
state_before: α : Type u_1
β : Type ?u.512
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ Finset.univ = {⊤, ⊥}

tactic: rw [Fintype.univ_bool]
state_before: α : Type u_1
β : Type ?u.512
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ Finset.map { toFun := ↑IsSimpleOrder.equivBool.symm, inj' := (_ : Function.Injective ↑IsSimpleOrder.equivBool.symm) }
      Finset.univ =
    {⊤, ⊥}

tactic: simp only [Finset.map_insert, Function.Embedding.coeFn_mk, Finset.map_singleton]
state_before: α : Type u_1
β : Type ?u.512
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ Finset.map { toFun := ↑IsSimpleOrder.equivBool.symm, inj' := (_ : Function.Injective ↑IsSimpleOrder.equivBool.symm) }
      {true, false} =
    {⊤, ⊥}

tactic: rfl
state_before: α : Type u_1
β : Type ?u.512
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ {↑IsSimpleOrder.equivBool.symm true, ↑IsSimpleOrder.equivBool.symm false} = {⊤, ⊥}