tasksource/leandojo huggingface dataset:
Theorem: Nat.evenOddRec_even
File: Mathlib/Data/Nat/EvenOddRec.lean

tactic: rw [evenOddRec, binaryRec_eq]
state_before: n : ℕ
P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
⊢ HEq (evenOddRec h0 h_even h_odd (bit false n)) (h_even n (evenOddRec h0 h_even h_odd n))

tactic: apply eq_rec_heq
state_before: n : ℕ
P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
⊢ HEq
    (match false, n,
      binaryRec h0
        (fun x x_1 x_2 =>
          match x, x_1, x_2 with
          | false, i, hi => (_ : 2 * i = bit0 i) ▸ h_even i hi
          | true, i, hi => (_ : 2 * i + 1 = bit1 i) ▸ h_odd i hi)
        n with
    | false, i, hi => (_ : 2 * i = bit0 i) ▸ h_even i hi
    | true, i, hi => (_ : 2 * i + 1 = bit1 i) ▸ h_odd i hi)
    (h_even n (evenOddRec h0 h_even h_odd n))

case h
n : ℕ
P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
⊢ (match false, 0, h0 with
    | false, i, hi => (_ : 2 * i = bit0 i) ▸ h_even i hi
    | true, i, hi => (_ : 2 * i + 1 = bit1 i) ▸ h_odd i hi) =
    h0

tactic: exact H
state_before: case h
n : ℕ
P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
⊢ (match false, 0, h0 with
    | false, i, hi => (_ : 2 * i = bit0 i) ▸ h_even i hi
    | true, i, hi => (_ : 2 * i + 1 = bit1 i) ▸ h_odd i hi) =
    h0
Theorem: ContinuousLinearMap.norm_precompL_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: rw [precompL, op_norm_flip, ← op_norm_flip L]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.1647067
𝕜₃ : Type ?u.1647070
E : Type u_2
Eₗ : Type u_5
F : Type ?u.1647079
Fₗ : Type u_4
G : Type ?u.1647085
Gₗ : Type u_3
𝓕 : Type ?u.1647091
inst✝¹⁸ : SeminormedAddCommGroup E
inst✝¹⁷ : SeminormedAddCommGroup Eₗ
inst✝¹⁶ : SeminormedAddCommGroup F
inst✝¹⁵ : SeminormedAddCommGroup Fₗ
inst✝¹⁴ : SeminormedAddCommGroup G
inst✝¹³ : SeminormedAddCommGroup Gₗ
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NontriviallyNormedField 𝕜₂
inst✝¹⁰ : NontriviallyNormedField 𝕜₃
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 Eₗ
inst✝⁷ : NormedSpace 𝕜₂ F
inst✝⁶ : NormedSpace 𝕜 Fₗ
inst✝⁵ : NormedSpace 𝕜₃ G
inst✝⁴ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ ‖precompL Eₗ L‖ ≤ ‖L‖

tactic: exact norm_precompR_le _ L.flip
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.1647067
𝕜₃ : Type ?u.1647070
E : Type u_2
Eₗ : Type u_5
F : Type ?u.1647079
Fₗ : Type u_4
G : Type ?u.1647085
Gₗ : Type u_3
𝓕 : Type ?u.1647091
inst✝¹⁸ : SeminormedAddCommGroup E
inst✝¹⁷ : SeminormedAddCommGroup Eₗ
inst✝¹⁶ : SeminormedAddCommGroup F
inst✝¹⁵ : SeminormedAddCommGroup Fₗ
inst✝¹⁴ : SeminormedAddCommGroup G
inst✝¹³ : SeminormedAddCommGroup Gₗ
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NontriviallyNormedField 𝕜₂
inst✝¹⁰ : NontriviallyNormedField 𝕜₃
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 Eₗ
inst✝⁷ : NormedSpace 𝕜₂ F
inst✝⁶ : NormedSpace 𝕜 Fₗ
inst✝⁵ : NormedSpace 𝕜₃ G
inst✝⁴ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ ‖precompR Eₗ (flip L)‖ ≤ ‖flip L‖
Theorem: MonoidAlgebra.lift_unique
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: conv_lhs =>
  rw [lift_unique' F]
  simp [lift_apply]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1375408
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.1375445
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : MonoidAlgebra k G →ₐ[k] A
f : MonoidAlgebra k G
⊢ ↑F f = sum f fun a b => b • ↑F (single a 1)
Theorem: multiplicity.Int.coe_nat_multiplicity
File: Mathlib/RingTheory/Multiplicity.lean

tactic: apply Part.ext'
state_before: α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
⊢ multiplicity ↑a ↑b = multiplicity a b

tactic: rw [← @finite_iff_dom ℕ, @finite_def ℕ, ← @finite_iff_dom ℤ, @finite_def ℤ]
state_before: case x
α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
⊢ (multiplicity ↑a ↑b).Dom ↔ (multiplicity a b).Dom

tactic: norm_cast
state_before: case x
α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
⊢ (∃ n, ¬↑a ^ (n + 1) ∣ ↑b) ↔ ∃ n, ¬a ^ (n + 1) ∣ b

tactic: intro h1 h2
state_before: case x
α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
⊢ ∀ (h₁ : (multiplicity ↑a ↑b).Dom) (h₂ : (multiplicity a b).Dom),
    Part.get (multiplicity ↑a ↑b) h₁ = Part.get (multiplicity a b) h₂

tactic: apply Nat.find_mono
state_before: case x.a
α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ Part.get (multiplicity a b) h2 ≤ Part.get (multiplicity ↑a ↑b) h1

tactic: norm_cast
state_before: case x.a.h
α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ ∀ (n : ℕ), (fun n => ¬↑a ^ (n + 1) ∣ ↑b) n → (fun n => ¬a ^ (n + 1) ∣ b) n

tactic: simp
state_before: case x.a.h
α : Type ?u.183606
inst✝ : Monoid α
a b : ℕ
h1 : (multiplicity ↑a ↑b).Dom
h2 : (multiplicity a b).Dom
⊢ ∀ (n : ℕ), (fun n => ¬a ^ (n + 1) ∣ b) n → (fun n => ¬a ^ (n + 1) ∣ b) n
Theorem: RingHom.Finite.comp
File: Mathlib/RingTheory/Finiteness.lean

tactic: letI := f.toAlgebra
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
⊢ Finite (RingHom.comp g f)

tactic: letI := g.toAlgebra
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
this : Algebra A B := toAlgebra f
⊢ Finite (RingHom.comp g f)

tactic: letI := (g.comp f).toAlgebra
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
this✝ : Algebra A B := toAlgebra f
this : Algebra B C := toAlgebra g
⊢ Finite (RingHom.comp g f)

tactic: letI : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
this✝¹ : Algebra A B := toAlgebra f
this✝ : Algebra B C := toAlgebra g
this : Algebra A C := toAlgebra (RingHom.comp g f)
⊢ Finite (RingHom.comp g f)

tactic: letI : Module.Finite A B := hf
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
this✝² : Algebra A B := toAlgebra f
this✝¹ : Algebra B C := toAlgebra g
this✝ : Algebra A C := toAlgebra (RingHom.comp g f)
this : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
⊢ Finite (RingHom.comp g f)

tactic: letI : Module.Finite B C := hg
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
this✝³ : Algebra A B := toAlgebra f
this✝² : Algebra B C := toAlgebra g
this✝¹ : Algebra A C := toAlgebra (RingHom.comp g f)
this✝ : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
this : Module.Finite A B := hf
⊢ Finite (RingHom.comp g f)

tactic: exact Module.Finite.trans B C
state_before: A : Type u_3
B : Type u_1
C : Type u_2
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
g : B →+* C
f : A →+* B
hg : Finite g
hf : Finite f
this✝⁴ : Algebra A B := toAlgebra f
this✝³ : Algebra B C := toAlgebra g
this✝² : Algebra A C := toAlgebra (RingHom.comp g f)
this✝¹ : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
this✝ : Module.Finite A B := hf
this : Module.Finite B C := hg
⊢ Finite (RingHom.comp g f)
Theorem: normal_exists_closure_subset
File: Mathlib/Topology/Separation.lean

tactic: have : Disjoint s (tᶜ) := Set.disjoint_left.mpr fun x hxs hxt => hxt (hst hxs)
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : NormalSpace α
s t : Set α
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t

tactic: rcases normal_separation hs (isClosed_compl_iff.2 ht) this with
  ⟨s', t', hs', ht', hss', htt', hs't'⟩
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : NormalSpace α
s t : Set α
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s (tᶜ)
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t

tactic: refine ⟨s', hs', hss', Subset.trans (closure_minimal ?_ (isClosed_compl_iff.2 ht'))
  (compl_subset_comm.1 htt')⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : NormalSpace α
s t : Set α
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s (tᶜ)
s' t' : Set α
hs' : IsOpen s'
ht' : IsOpen t'
hss' : s ⊆ s'
htt' : tᶜ ⊆ t'
hs't' : Disjoint s' t'
⊢ ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t

tactic: exact fun x hxs hxt => hs't'.le_bot ⟨hxs, hxt⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : NormalSpace α
s t : Set α
hs : IsClosed s
ht : IsOpen t
hst : s ⊆ t
this : Disjoint s (tᶜ)
s' t' : Set α
hs' : IsOpen s'
ht' : IsOpen t'
hss' : s ⊆ s'
htt' : tᶜ ⊆ t'
hs't' : Disjoint s' t'
⊢ s' ⊆ t'ᶜ
Theorem: MeasureTheory.Measure.sum_fintype
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext1 s hs
state_before: α : Type u_2
β : Type ?u.341463
γ : Type ?u.341466
δ : Type ?u.341469
ι : Type u_1
R : Type ?u.341475
R' : Type ?u.341478
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : Fintype ι
μ : ι → Measure α
⊢ sum μ = ∑ i : ι, μ i

tactic: simp only [sum_apply, finset_sum_apply, hs, tsum_fintype]
state_before: case h
α : Type u_2
β : Type ?u.341463
γ : Type ?u.341466
δ : Type ?u.341469
ι : Type u_1
R : Type ?u.341475
R' : Type ?u.341478
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : Fintype ι
μ : ι → Measure α
s : Set α
hs : MeasurableSet s
⊢ ↑↑(sum μ) s = ↑↑(∑ i : ι, μ i) s
Theorem: Finset.powersetLen_succ_insert
File: Mathlib/Data/Finset/Powerset.lean

tactic: rw [powersetLen_eq_filter, powerset_insert, filter_union, ← powersetLen_eq_filter]
state_before: α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
⊢ powersetLen (Nat.succ n) (insert x s) = powersetLen (Nat.succ n) s ∪ image (insert x) (powersetLen n s)

tactic: congr
state_before: α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
⊢ powersetLen (Nat.succ n) s ∪ filter (fun x => card x = Nat.succ n) (image (insert x) (powerset s)) =
    powersetLen (Nat.succ n) s ∪ image (insert x) (powersetLen n s)

tactic: rw [powersetLen_eq_filter, image_filter]
state_before: case e_a
α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
⊢ filter (fun x => card x = Nat.succ n) (image (insert x) (powerset s)) = image (insert x) (powersetLen n s)

tactic: congr 1
state_before: case e_a
α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
⊢ image (insert x) (filter ((fun x => card x = Nat.succ n) ∘ insert x) (powerset s)) =
    image (insert x) (filter (fun x => card x = n) (powerset s))

tactic: ext t
state_before: case e_a.e_s
α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
⊢ filter ((fun x => card x = Nat.succ n) ∘ insert x) (powerset s) = filter (fun x => card x = n) (powerset s)

tactic: simp only [mem_powerset, mem_filter, Function.comp_apply, and_congr_right_iff]
state_before: case e_a.e_s.a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
t : Finset α
⊢ t ∈ filter ((fun x => card x = Nat.succ n) ∘ insert x) (powerset s) ↔ t ∈ filter (fun x => card x = n) (powerset s)

tactic: intro ht
state_before: case e_a.e_s.a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
t : Finset α
⊢ t ⊆ s → (card (insert x t) = Nat.succ n ↔ card t = n)

tactic: have : x ∉ t := fun H => h (ht H)
state_before: case e_a.e_s.a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
t : Finset α
ht : t ⊆ s
⊢ card (insert x t) = Nat.succ n ↔ card t = n

tactic: simp [card_insert_of_not_mem this, Nat.succ_inj']
state_before: case e_a.e_s.a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
x : α
s : Finset α
h : ¬x ∈ s
n : ℕ
t : Finset α
ht : t ⊆ s
this : ¬x ∈ t
⊢ card (insert x t) = Nat.succ n ↔ card t = n
Theorem: Rat.toNNRat_eq_zero
File: Mathlib/Data/Rat/NNRat.lean

tactic: simpa [-toNNRat_pos] using (@toNNRat_pos q).not
state_before: p q : ℚ
⊢ toNNRat q = 0 ↔ q ≤ 0
Theorem: Int.emod_emod_of_dvd
File: Std/Data/Int/DivMod.lean

tactic: conv => rhs; rw [← emod_add_ediv n k]
state_before: n m k : Int
h : m ∣ k
⊢ n % k % m = n % m

tactic: match k, h with
| _, ⟨t, rfl⟩ => rw [Int.mul_assoc, add_mul_emod_self_left]
state_before: n m k : Int
h : m ∣ k
⊢ n % k % m = (n % k + k * (n / k)) % m

tactic: rw [Int.mul_assoc, add_mul_emod_self_left]
state_before: n m k : Int
h : m ∣ k
t : Int
⊢ n % (m * t) % m = (n % (m * t) + m * t * (n / (m * t))) % m
Theorem: WithTop.add_eq_coe
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: simp [none_eq_top]
state_before: α : Type u
β : Type v
inst✝ : Add α
a b✝ c✝ d : WithTop α
x y : α
b : WithTop α
c : α
⊢ none + b = ↑c ↔ ∃ a' b', ↑a' = none ∧ ↑b' = b ∧ a' + b' = c

tactic: simp [none_eq_top]
state_before: α : Type u
β : Type v
inst✝ : Add α
a✝ b c✝ d : WithTop α
x y a c : α
⊢ Option.some a + none = ↑c ↔ ∃ a' b', ↑a' = Option.some a ∧ ↑b' = none ∧ a' + b' = c

tactic: simp only [some_eq_coe, ← coe_add, coe_eq_coe, exists_and_left, exists_eq_left]
state_before: α : Type u
β : Type v
inst✝ : Add α
a✝ b✝ c✝ d : WithTop α
x y a b c : α
⊢ Option.some a + Option.some b = ↑c ↔ ∃ a' b', ↑a' = Option.some a ∧ ↑b' = Option.some b ∧ a' + b' = c
Theorem: IntermediateField.adjoin_algebraic_toSubalgebra
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp only [isAlgebraic_iff_isIntegral] at hS
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ (x : E), x ∈ S → IsAlgebraic F x
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S

tactic: have : Algebra.IsIntegral F (Algebra.adjoin F S) := by
  rwa [← le_integralClosure_iff_isIntegral, Algebra.adjoin_le_iff]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ (x : E), x ∈ S → IsIntegral F x
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S

tactic: have := isField_of_isIntegral_of_isField' this (Field.toIsField F)
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ (x : E), x ∈ S → IsIntegral F x
this : Algebra.IsIntegral F { x // x ∈ Algebra.adjoin F S }
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S

tactic: rw [← ((Algebra.adjoin F S).toIntermediateField' this).eq_adjoin_of_eq_algebra_adjoin F S] <;> rfl
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ (x : E), x ∈ S → IsIntegral F x
this✝ : Algebra.IsIntegral F { x // x ∈ Algebra.adjoin F S }
this : IsField { x // x ∈ Algebra.adjoin F S }
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S

tactic: rwa [← le_integralClosure_iff_isIntegral, Algebra.adjoin_le_iff]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ (x : E), x ∈ S → IsIntegral F x
⊢ Algebra.IsIntegral F { x // x ∈ Algebra.adjoin F S }
Theorem: Polynomial.IsUnitTrinomial.coeff_isUnit
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: obtain ⟨k, m, n, hkm, hmn, u, v, w, rfl⟩ := hp
state_before: p q : ℤ[X]
hp : IsUnitTrinomial p
k : ℕ
hk : k ∈ support p
⊢ IsUnit (coeff p k)

tactic: have := support_trinomial' k m n (u : ℤ) v w hk
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k✝ k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
hk : k✝ ∈ support (trinomial k m n ↑u ↑v ↑w)
⊢ IsUnit (coeff (trinomial k m n ↑u ↑v ↑w) k✝)

tactic: rw [mem_insert, mem_insert, mem_singleton] at this
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k✝ k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
hk : k✝ ∈ support (trinomial k m n ↑u ↑v ↑w)
this : k✝ ∈ {k, m, n}
⊢ IsUnit (coeff (trinomial k m n ↑u ↑v ↑w) k✝)

tactic: rcases this with (rfl | rfl | rfl)
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k✝ k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
hk : k✝ ∈ support (trinomial k m n ↑u ↑v ↑w)
this : k✝ = k ∨ k✝ = m ∨ k✝ = n
⊢ IsUnit (coeff (trinomial k m n ↑u ↑v ↑w) k✝)

tactic: refine' ⟨u, by rw [trinomial_trailing_coeff' hkm hmn]⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.inl
q : ℤ[X]
k m n : ℕ
hmn : m < n
u v w : ℤˣ
hkm : k < m
hk : k ∈ support (trinomial k m n ↑u ↑v ↑w)
⊢ IsUnit (coeff (trinomial k m n ↑u ↑v ↑w) k)

tactic: rw [trinomial_trailing_coeff' hkm hmn]
state_before: q : ℤ[X]
k m n : ℕ
hmn : m < n
u v w : ℤˣ
hkm : k < m
hk : k ∈ support (trinomial k m n ↑u ↑v ↑w)
⊢ ↑u = coeff (trinomial k m n ↑u ↑v ↑w) k

tactic: refine' ⟨v, by rw [trinomial_middle_coeff hkm hmn]⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.inr.inl
q : ℤ[X]
k✝ k n : ℕ
u v w : ℤˣ
hkm : k < k✝
hmn : k✝ < n
hk : k✝ ∈ support (trinomial k k✝ n ↑u ↑v ↑w)
⊢ IsUnit (coeff (trinomial k k✝ n ↑u ↑v ↑w) k✝)

tactic: rw [trinomial_middle_coeff hkm hmn]
state_before: q : ℤ[X]
k✝ k n : ℕ
u v w : ℤˣ
hkm : k < k✝
hmn : k✝ < n
hk : k✝ ∈ support (trinomial k k✝ n ↑u ↑v ↑w)
⊢ ↑v = coeff (trinomial k k✝ n ↑u ↑v ↑w) k✝

tactic: refine' ⟨w, by rw [trinomial_leading_coeff' hkm hmn]⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.inr.inr
q : ℤ[X]
k✝ k m : ℕ
hkm : k < m
u v w : ℤˣ
hmn : m < k✝
hk : k✝ ∈ support (trinomial k m k✝ ↑u ↑v ↑w)
⊢ IsUnit (coeff (trinomial k m k✝ ↑u ↑v ↑w) k✝)

tactic: rw [trinomial_leading_coeff' hkm hmn]
state_before: q : ℤ[X]
k✝ k m : ℕ
hkm : k < m
u v w : ℤˣ
hmn : m < k✝
hk : k✝ ∈ support (trinomial k m k✝ ↑u ↑v ↑w)
⊢ ↑w = coeff (trinomial k m k✝ ↑u ↑v ↑w) k✝
Theorem: IsCoprime.prod_right_iff
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: simpa only [isCoprime_comm] using IsCoprime.prod_left_iff (R := R)
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
⊢ IsCoprime x (∏ i in t, s i) ↔ ∀ (i : I), i ∈ t → IsCoprime x (s i)
Theorem: HasSum.mul_left
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only using h.map (AddMonoidHom.mulLeft a₂) (continuous_const.mul continuous_id)
state_before: ι : Type u_2
κ : Type ?u.64
R : Type ?u.67
α : Type u_1
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂✝ a₂ : α
h : HasSum f a₁
⊢ HasSum (fun i => a₂ * f i) (a₂ * a₁)
Theorem: Algebra.TensorProduct.tmul_pow
File: Mathlib/RingTheory/TensorProduct.lean

tactic: induction' k with k ih
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v₁
inst✝³ : Semiring A
inst✝² : Algebra R A
B : Type v₂
inst✝¹ : Semiring B
inst✝ : Algebra R B
a : A
b : B
k : ℕ
⊢ a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k)

tactic: simp [one_def]
state_before: case zero
R : Type u
inst✝⁴ : CommSemiring R
A : Type v₁
inst✝³ : Semiring A
inst✝² : Algebra R A
B : Type v₂
inst✝¹ : Semiring B
inst✝ : Algebra R B
a : A
b : B
⊢ a ⊗ₜ[R] b ^ Nat.zero = (a ^ Nat.zero) ⊗ₜ[R] (b ^ Nat.zero)

tactic: simp [pow_succ, ih]
state_before: case succ
R : Type u
inst✝⁴ : CommSemiring R
A : Type v₁
inst✝³ : Semiring A
inst✝² : Algebra R A
B : Type v₂
inst✝¹ : Semiring B
inst✝ : Algebra R B
a : A
b : B
k : ℕ
ih : a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k)
⊢ a ⊗ₜ[R] b ^ Nat.succ k = (a ^ Nat.succ k) ⊗ₜ[R] (b ^ Nat.succ k)
Theorem: tendsto_of_uniformContinuous_subtype
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [(@map_nhds_subtype_coe_eq_nhds α _ s a (mem_of_mem_nhds ha) ha).symm]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.149761
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
a : α
hf : UniformContinuous fun x => f ↑x
ha : s ∈ 𝓝 a
⊢ Tendsto f (𝓝 a) (𝓝 (f a))

tactic: exact tendsto_map' hf.continuous.continuousAt
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.149761
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
a : α
hf : UniformContinuous fun x => f ↑x
ha : s ∈ 𝓝 a
⊢ Tendsto f (map Subtype.val (𝓝 { val := a, property := (_ : a ∈ s) })) (𝓝 (f a))
Theorem: ENNReal.ofReal_le_ofReal
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [ENNReal.ofReal, Real.toNNReal_le_toNNReal h]
state_before: α : Type ?u.805537
β : Type ?u.805540
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
h : p ≤ q
⊢ ENNReal.ofReal p ≤ ENNReal.ofReal q
Theorem: IsQuasiSeparated.of_subset
File: Mathlib/Topology/QuasiSeparated.lean

tactic: intro U V hU hU' hU'' hV hV' hV''
state_before: α : Type u_1
β : Type ?u.18691
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s t : Set α
ht : IsQuasiSeparated t
h : s ⊆ t
⊢ IsQuasiSeparated s

tactic: exact ht U V (hU.trans h) hU' hU'' (hV.trans h) hV' hV''
state_before: α : Type u_1
β : Type ?u.18691
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s t : Set α
ht : IsQuasiSeparated t
h : s ⊆ t
U V : Set α
hU : U ⊆ s
hU' : IsOpen U
hU'' : IsCompact U
hV : V ⊆ s
hV' : IsOpen V
hV'' : IsCompact V
⊢ IsCompact (U ∩ V)
Theorem: FreeGroup.Red.step_invRev_iff
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: simpa only [invRev_invRev] using h.invRev
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
h : Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂)
⊢ Step L₁ L₂
Theorem: IsBoundedBilinearMap.fderivWithin
File: Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean

tactic: rw [DifferentiableAt.fderivWithin (h.differentiableAt p) hxs]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.68931
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
hxs : UniqueDiffWithinAt 𝕜 u p
⊢ fderivWithin 𝕜 b u p = deriv h p

tactic: exact h.fderiv p
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.68931
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
hxs : UniqueDiffWithinAt 𝕜 u p
⊢ fderiv 𝕜 b p = deriv h p
Theorem: Metric.iUnion_inter_closedBall_nat
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← inter_iUnion, iUnion_closedBall_nat, inter_univ]
state_before: α : Type u
β : Type v
X : Type ?u.43642
ι : Type ?u.43645
inst✝ : PseudoMetricSpace α
x✝ y z : α
δ ε ε₁ ε₂ : ℝ
s✝ s : Set α
x : α
⊢ (⋃ (n : ℕ), s ∩ closedBall x ↑n) = s
Theorem: isComplete_iff_ultrafilter'
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp only [le_principal_iff, Ultrafilter.mem_coe]
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
⊢ (∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x) ↔
    ∀ (l : Ultrafilter α), Cauchy ↑l → s ∈ l → ∃ x, x ∈ s ∧ ↑l ≤ 𝓝 x