tasksource/leandojo huggingface dataset:
Theorem: IntermediateField.aeval_coe
File: Mathlib/FieldTheory/IntermediateField.lean

tactic: refine' Polynomial.induction_on' P (fun f g hf hg => _) fun n r => _
state_before: K : Type u_2
L : Type u_3
L' : Type ?u.178908
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field L'
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra K L'
S : IntermediateField K L
R : Type u_1
inst✝³ : CommRing R
inst✝² : Algebra R K
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : { x // x ∈ S }
P : R[X]
⊢ ↑(aeval ↑x) P = ↑(↑(aeval x) P)

tactic: rw [aeval_add, aeval_add, AddMemClass.coe_add, hf, hg]
state_before: case refine'_1
K : Type u_2
L : Type u_3
L' : Type ?u.178908
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field L'
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra K L'
S : IntermediateField K L
R : Type u_1
inst✝³ : CommRing R
inst✝² : Algebra R K
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : { x // x ∈ S }
P f g : R[X]
hf : ↑(aeval ↑x) f = ↑(↑(aeval x) f)
hg : ↑(aeval ↑x) g = ↑(↑(aeval x) g)
⊢ ↑(aeval ↑x) (f + g) = ↑(↑(aeval x) (f + g))

tactic: simp only [MulMemClass.coe_mul, aeval_monomial, SubmonoidClass.coe_pow, mul_eq_mul_right_iff]
state_before: case refine'_2
K : Type u_2
L : Type u_3
L' : Type ?u.178908
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field L'
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra K L'
S : IntermediateField K L
R : Type u_1
inst✝³ : CommRing R
inst✝² : Algebra R K
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : { x // x ∈ S }
P : R[X]
n : ℕ
r : R
⊢ ↑(aeval ↑x) (↑(monomial n) r) = ↑(↑(aeval x) (↑(monomial n) r))

tactic: left
state_before: case refine'_2
K : Type u_2
L : Type u_3
L' : Type ?u.178908
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field L'
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra K L'
S : IntermediateField K L
R : Type u_1
inst✝³ : CommRing R
inst✝² : Algebra R K
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : { x // x ∈ S }
P : R[X]
n : ℕ
r : R
⊢ ↑(algebraMap R L) r = ↑(↑(algebraMap R { x // x ∈ S }) r) ∨ ↑x ^ n = 0

tactic: rfl
state_before: case refine'_2.h
K : Type u_2
L : Type u_3
L' : Type ?u.178908
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field L'
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra K L'
S : IntermediateField K L
R : Type u_1
inst✝³ : CommRing R
inst✝² : Algebra R K
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
x : { x // x ∈ S }
P : R[X]
n : ℕ
r : R
⊢ ↑(algebraMap R L) r = ↑(↑(algebraMap R { x // x ∈ S }) r)
Theorem: LinearMap.range_dualMap_le_dualAnnihilator_ker
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rintro _ ⟨ψ, rfl⟩
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
⊢ range (dualMap f) ≤ Submodule.dualAnnihilator (ker f)

tactic: simp_rw [Submodule.mem_dualAnnihilator, mem_ker]
state_before: case intro
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
ψ : Dual R M₂
⊢ ↑(dualMap f) ψ ∈ Submodule.dualAnnihilator (ker f)

tactic: rintro x hx
state_before: case intro
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
ψ : Dual R M₂
⊢ ∀ (w : M₁), ↑f w = 0 → ↑(↑(dualMap f) ψ) w = 0

tactic: rw [dualMap_apply, hx, map_zero]
state_before: case intro
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
ψ : Dual R M₂
x : M₁
hx : ↑f x = 0
⊢ ↑(↑(dualMap f) ψ) x = 0
Theorem: MonotoneOn.sum_le_integral
File: Mathlib/Analysis/SumIntegralComparisons.lean

tactic: rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hf : MonotoneOn f (Icc x₀ (x₀ + ↑a))
⊢ ∑ i in Finset.range a, f (x₀ + ↑i) ≤ ∫ (x : ℝ) in x₀..x₀ + ↑a, f x

tactic: exact hf.neg.integral_le_sum
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hf : MonotoneOn f (Icc x₀ (x₀ + ↑a))
⊢ (∫ (x : ℝ) in x₀..x₀ + ↑a, -f x) ≤ ∑ x in Finset.range a, -f (x₀ + ↑x)
Theorem: MeasureTheory.Measure.OuterRegular.map
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: refine' ⟨fun A hA r hr => _⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ✝ : Measure α
inst✝⁴ : OpensMeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
f : α ≃ₜ β
μ : Measure α
inst✝ : OuterRegular μ
⊢ OuterRegular (map (↑f) μ)

tactic: rw [map_apply f.measurable hA, ← f.image_symm] at hr
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ✝ : Measure α
inst✝⁴ : OpensMeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
f : α ≃ₜ β
μ : Measure α
inst✝ : OuterRegular μ
A : Set β
hA : MeasurableSet A
r : ℝ≥0∞
hr : r > ↑↑(map (↑f) μ) A
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑(map (↑f) μ) U < r

tactic: rcases Set.exists_isOpen_lt_of_lt _ r hr with ⟨U, hAU, hUo, hU⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ✝ : Measure α
inst✝⁴ : OpensMeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
f : α ≃ₜ β
μ : Measure α
inst✝ : OuterRegular μ
A : Set β
hA : MeasurableSet A
r : ℝ≥0∞
hr : r > ↑↑μ (↑(Homeomorph.symm f) '' A)
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑(map (↑f) μ) U < r

tactic: have : IsOpen (f.symm ⁻¹' U) := hUo.preimage f.symm.continuous
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ✝ : Measure α
inst✝⁴ : OpensMeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
f : α ≃ₜ β
μ : Measure α
inst✝ : OuterRegular μ
A : Set β
hA : MeasurableSet A
r : ℝ≥0∞
hr : r > ↑↑μ (↑(Homeomorph.symm f) '' A)
U : Set α
hAU : U ⊇ ↑(Homeomorph.symm f) '' A
hUo : IsOpen U
hU : ↑↑μ U < r
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑(map (↑f) μ) U < r

tactic: refine' ⟨f.symm ⁻¹' U, image_subset_iff.1 hAU, this, _⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ✝ : Measure α
inst✝⁴ : OpensMeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
f : α ≃ₜ β
μ : Measure α
inst✝ : OuterRegular μ
A : Set β
hA : MeasurableSet A
r : ℝ≥0∞
hr : r > ↑↑μ (↑(Homeomorph.symm f) '' A)
U : Set α
hAU : U ⊇ ↑(Homeomorph.symm f) '' A
hUo : IsOpen U
hU : ↑↑μ U < r
this : IsOpen (↑(Homeomorph.symm f) ⁻¹' U)
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑(map (↑f) μ) U < r

tactic: rwa [map_apply f.measurable this.measurableSet, f.preimage_symm, f.preimage_image]
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ✝ : Measure α
inst✝⁴ : OpensMeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
f : α ≃ₜ β
μ : Measure α
inst✝ : OuterRegular μ
A : Set β
hA : MeasurableSet A
r : ℝ≥0∞
hr : r > ↑↑μ (↑(Homeomorph.symm f) '' A)
U : Set α
hAU : U ⊇ ↑(Homeomorph.symm f) '' A
hUo : IsOpen U
hU : ↑↑μ U < r
this : IsOpen (↑(Homeomorph.symm f) ⁻¹' U)
⊢ ↑↑(map (↑f) μ) (↑(Homeomorph.symm f) ⁻¹' U) < r
Theorem: Primrec.fin_app
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type ?u.369919
β : Type ?u.369922
γ : Type ?u.369925
σ : Type u_1
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
x✝ : (Fin n → σ) × Fin n
v : Fin n → σ
i : Fin n
⊢ Vector.get (Vector.ofFn (v, i).fst) (v, i).snd = id (v, i).fst (v, i).snd
Theorem: PNat.find_le_iff
File: Mathlib/Data/PNat/Find.lean

tactic: simp only [exists_prop, ← lt_add_one_iff, find_lt_iff]
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n✝ m n : ℕ+
⊢ PNat.find h ≤ n ↔ ∃ m, m ≤ n ∧ p m
Theorem: PNat.mod_coe
File: Mathlib/Data/PNat/Defs.lean

tactic: dsimp [mod, modDiv]
state_before: m k : ℕ+
⊢ ↑(mod m k) = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k

tactic: cases (m : ℕ) % (k : ℕ) with
| zero =>
  rw [if_pos rfl]
  rfl
| succ n =>
  rw [if_neg n.succ_ne_zero]
  rfl
state_before: m k : ℕ+
⊢ ↑(modDivAux k (↑m % ↑k) (↑m / ↑k)).fst = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k

tactic: rw [if_pos rfl]
state_before: case zero
m k : ℕ+
⊢ ↑(modDivAux k zero (↑m / ↑k)).fst = if zero = 0 then ↑k else zero

tactic: rfl
state_before: case zero
m k : ℕ+
⊢ ↑(modDivAux k zero (↑m / ↑k)).fst = ↑k

tactic: rw [if_neg n.succ_ne_zero]
state_before: case succ
m k : ℕ+
n : ℕ
⊢ ↑(modDivAux k (succ n) (↑m / ↑k)).fst = if succ n = 0 then ↑k else succ n

tactic: rfl
state_before: case succ
m k : ℕ+
n : ℕ
⊢ ↑(modDivAux k (succ n) (↑m / ↑k)).fst = succ n
Theorem: t0Space_iff_or_not_mem_closure
File: Mathlib/Topology/Separation.lean

tactic: simp only [t0Space_iff_not_inseparable, inseparable_iff_mem_closure, not_and_or]
state_before: α✝ : Type u
β : Type v
inst✝¹ : TopologicalSpace α✝
α : Type u
inst✝ : TopologicalSpace α
⊢ T0Space α ↔ ∀ (a b : α), a ≠ b → ¬a ∈ closure {b} ∨ ¬b ∈ closure {a}
Theorem: Function.Antiperiodic.int_odd_mul_antiperiodic
File: Mathlib/Algebra/Periodic.lean

tactic: rw [← add_assoc, h, h.periodic.int_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.151870
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : Ring α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℤ
x : α
⊢ f (x + (↑n * (2 * c) + c)) = -f x
Theorem: tendstoLocallyUniformlyOn_univ
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp [TendstoLocallyUniformlyOn, TendstoLocallyUniformly, nhdsWithin_univ]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
⊢ TendstoLocallyUniformlyOn F f p univ ↔ TendstoLocallyUniformly F f p
Theorem: CategoryTheory.transferNatTransSelf_of_iso
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: suffices IsIso ((transferNatTransSelf adj₁ adj₂).symm (transferNatTransSelf adj₁ adj₂ f))
  by simpa using this
state_before: C : Type u₁
D : Type u₂
inst✝² : Category C
inst✝¹ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
inst✝ : IsIso (↑(transferNatTransSelf adj₁ adj₂) f)
⊢ IsIso f

tactic: infer_instance
state_before: C : Type u₁
D : Type u₂
inst✝² : Category C
inst✝¹ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
inst✝ : IsIso (↑(transferNatTransSelf adj₁ adj₂) f)
⊢ IsIso (↑(transferNatTransSelf adj₁ adj₂).symm (↑(transferNatTransSelf adj₁ adj₂) f))

tactic: simpa using this
state_before: C : Type u₁
D : Type u₂
inst✝² : Category C
inst✝¹ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
inst✝ : IsIso (↑(transferNatTransSelf adj₁ adj₂) f)
this : IsIso (↑(transferNatTransSelf adj₁ adj₂).symm (↑(transferNatTransSelf adj₁ adj₂) f))
⊢ IsIso f
Theorem: UniformSpace.comap_iInf
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext : 1
state_before: α✝ : Type ua
β : Type ub
γ✝ : Type uc
δ : Type ud
ι✝ : Sort ?u.138231
ι : Sort u_1
α : Type u_2
γ : Type u_3
u : ι → UniformSpace γ
f : α → γ
⊢ comap f (⨅ (i : ι), u i) = ⨅ (i : ι), comap f (u i)

tactic: simp [uniformity_comap, iInf_uniformity]
state_before: case a
α✝ : Type ua
β : Type ub
γ✝ : Type uc
δ : Type ud
ι✝ : Sort ?u.138231
ι : Sort u_1
α : Type u_2
γ : Type u_3
u : ι → UniformSpace γ
f : α → γ
⊢ 𝓤 α = 𝓤 α
Theorem: Ideal.finite_mulSupport_inv
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: rw [mulSupport]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite
    (mulSupport fun v =>
      ↑v.asIdeal ^ (-↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I)))))

tactic: simp_rw [zpow_neg, Ne.def, inv_eq_one]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite
    {x | ↑x.asIdeal ^ (-↑(Associates.count (Associates.mk x.asIdeal) (Associates.factors (Associates.mk I)))) ≠ 1}

tactic: exact finite_mulSupport_coe hI
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite
    {x | ¬↑x.asIdeal ^ ↑(Associates.count (Associates.mk x.asIdeal) (Associates.factors (Associates.mk I))) = 1}
Theorem: UniformGroup.uniformity_countably_generated
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: rw [uniformity_eq_comap_nhds_one]
state_before: α : Type u_1
β : Type ?u.166678
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : IsCountablyGenerated (𝓝 1)
⊢ IsCountablyGenerated (𝓤 α)

tactic: exact Filter.comap.isCountablyGenerated _ _
state_before: α : Type u_1
β : Type ?u.166678
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : IsCountablyGenerated (𝓝 1)
⊢ IsCountablyGenerated (comap (fun x => x.snd / x.fst) (𝓝 1))
Theorem: intervalIntegral.integral_interval_sub_interval_comm'
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [integral_interval_sub_interval_comm hab hcd hac, integral_symm b d, integral_symm a c,
  sub_neg_eq_add, sub_eq_neg_add]
state_before: ι : Type ?u.16082722
𝕜 : Type ?u.16082725
E : Type u_1
F : Type ?u.16082731
A : Type ?u.16082734
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
hab : IntervalIntegrable f μ a b
hcd : IntervalIntegrable f μ c d
hac : IntervalIntegrable f μ a c
⊢ ((∫ (x : ℝ) in a..b, f x ∂μ) - ∫ (x : ℝ) in c..d, f x ∂μ) = (∫ (x : ℝ) in d..b, f x ∂μ) - ∫ (x : ℝ) in c..a, f x ∂μ
Theorem: InnerProductSpace.Core.inner_mul_inner_self_le
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: 𝕜 : Type u_1
E : Type ?u.652623
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ‖inner x y‖ * ‖inner y x‖ ≤ ↑re (inner x x) * ↑re (inner y y)

tactic: simpa only [inner_zero_left, map_zero, MulZeroClass.zero_mul, norm_zero] using le_rfl
state_before: case inl
𝕜 : Type u_1
E : Type ?u.652623
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
y : F
⊢ ‖inner 0 y‖ * ‖inner y 0‖ ≤ ↑re (inner 0 0) * ↑re (inner y y)

tactic: have hx' : 0 < normSqF x := inner_self_nonneg.lt_of_ne' (mt normSq_eq_zero.1 hx)
state_before: case inr
𝕜 : Type u_1
E : Type ?u.652623
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
hx : x ≠ 0
⊢ ‖inner x y‖ * ‖inner y x‖ ≤ ↑re (inner x x) * ↑re (inner y y)

tactic: rw [← sub_nonneg, ← mul_nonneg_iff_right_nonneg_of_pos hx', ← normSq, ← normSq,
  norm_inner_symm y, ← sq, ← cauchy_schwarz_aux]
state_before: case inr
𝕜 : Type u_1
E : Type ?u.652623
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
hx : x ≠ 0
hx' : 0 < normSq x
⊢ ‖inner x y‖ * ‖inner y x‖ ≤ ↑re (inner x x) * ↑re (inner y y)

tactic: exact inner_self_nonneg
state_before: case inr
𝕜 : Type u_1
E : Type ?u.652623
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
hx : x ≠ 0
hx' : 0 < normSq x
⊢ 0 ≤ normSq (inner x y • x - inner x x • y)
Theorem: Polynomial.coeff_mul_monomial
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [← C_mul_X_pow_eq_monomial, ← X_pow_mul, ← mul_assoc, coeff_mul_C, coeff_mul_X_pow]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r✝ p : R[X]
n d : ℕ
r : R
⊢ coeff (p * ↑(monomial n) r) (d + n) = coeff p d * r
Theorem: Ideal.map_eq_bot_iff_of_injective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [map_eq_bot_iff_le_ker, (RingHom.injective_iff_ker_eq_bot f).mp hf, le_bot_iff]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
inst✝¹ : Ring R
inst✝ : Ring S
rc : RingHomClass F R S
I : Ideal R
f : F
hf : Function.Injective ↑f
⊢ map f I = ⊥ ↔ I = ⊥
Theorem: Function.mem_periodicOrbit_iff
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp only [periodicOrbit, Cycle.mem_coe_iff, List.mem_map, List.mem_range]
state_before: α : Type u_1
β : Type ?u.30921
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ y ∈ periodicOrbit f x ↔ ∃ n, (f^[n]) x = y

tactic: use fun ⟨a, _, ha'⟩ => ⟨a, ha'⟩
state_before: α : Type u_1
β : Type ?u.30921
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ (∃ a, a < minimalPeriod f x ∧ (f^[a]) x = y) ↔ ∃ n, (f^[n]) x = y

tactic: rintro ⟨n, rfl⟩
state_before: α : Type u_1
β : Type ?u.30921
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ (∃ n, (f^[n]) x = y) → ∃ a, a < minimalPeriod f x ∧ (f^[a]) x = y

tactic: use n % minimalPeriod f x, mod_lt _ (minimalPeriod_pos_of_mem_periodicPts hx)
state_before: case intro
α : Type u_1
β : Type ?u.30921
f fa : α → α
fb : β → β
x : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ ∃ a, a < minimalPeriod f x ∧ (f^[a]) x = (f^[n]) x

tactic: rw [iterate_mod_minimalPeriod_eq]
state_before: case intro
α : Type u_1
β : Type ?u.30921
f fa : α → α
fb : β → β
x : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ (f^[n % minimalPeriod f x]) x = (f^[n]) x
Theorem: List.mem_append
File: Std/Data/List/Lemmas.lean

tactic: induction s <;> simp_all [or_assoc]
state_before: α : Type u_1
a : α
s t : List α
⊢ a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t
Theorem: FreeAbelianGroup.lift.of
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: convert Abelianization.lift.of
   (FreeGroup.lift f (β := Multiplicative β)) (FreeGroup.of x) using 1
state_before: α : Type u
β : Type v
inst✝ : AddCommGroup β
f : α → β
x : α
⊢ ↑(↑lift f) (of x) = f x

tactic: exact (FreeGroup.lift.of (β := Multiplicative β)).symm
state_before: case h.e'_3.h
α : Type u
β : Type v
inst✝ : AddCommGroup β
f : α → β
x : α
e_1✝ : (fun x => β) (of x) = (fun x => Multiplicative β) (↑Abelianization.of (FreeGroup.of x))
⊢ f x = ↑(↑FreeGroup.lift f) (FreeGroup.of x)
Theorem: Turing.TM0.step_supports
File: Mathlib/Computability/TuringMachine.lean

tactic: intro ⟨q, T⟩ c' h₁ h₂
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
⊢ ∀ {c c' : Cfg₀}, c' ∈ step M c → c.q ∈ S → c'.q ∈ S

tactic: rcases Option.map_eq_some'.1 h₁ with ⟨⟨q', a⟩, h, rfl⟩
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
c' : Cfg₀
h₁ : c' ∈ step M { q := q, Tape := T }
h₂ : { q := q, Tape := T }.q ∈ S
⊢ c'.q ∈ S

tactic: exact ss.2 h h₂
state_before: case intro.mk.intro
Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
h₂ : { q := q, Tape := T }.q ∈ S
q' : Λ
a : Stmt₀
h : M q T.head = some (q', a)
h₁ :
  (fun x =>
        match x with
        | (q', a) =>
          { q := q',
            Tape :=
              match a with
              | Stmt.move d => Tape.move d T
              | Stmt.write a => Tape.write a T })
      (q', a) ∈
    step M { q := q, Tape := T }
⊢ ((fun x =>
          match x with
          | (q', a) =>
            { q := q',
              Tape :=
                match a with
                | Stmt.move d => Tape.move d T
                | Stmt.write a => Tape.write a T })
        (q', a)).q ∈
    S
Theorem: CategoryTheory.ConcreteCategory.bijective_of_isIso
File: Mathlib/CategoryTheory/ConcreteCategory/Basic.lean

tactic: rw [← isIso_iff_bijective]
state_before: C : Type v
inst✝² : Category C
inst✝¹ : ConcreteCategory C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ Function.Bijective ((forget C).map f)

tactic: infer_instance
state_before: C : Type v
inst✝² : Category C
inst✝¹ : ConcreteCategory C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ IsIso ((forget C).map f)
Theorem: IsAlgClosed.ringEquivOfCardinalEqOfCharEq
File: Mathlib/FieldTheory/IsAlgClosed/Classification.lean

tactic: apply Classical.choice
state_before: K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
inst✝¹ : CharP K p
inst✝ : CharP L p
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
⊢ K ≃+* L

tactic: rcases CharP.char_is_prime_or_zero K p with (hp | hp)
state_before: case a
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
inst✝¹ : CharP K p
inst✝ : CharP L p
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
⊢ Nonempty (K ≃+* L)

tactic: haveI : Fact p.Prime := ⟨hp⟩
state_before: case a.inl
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
inst✝¹ : CharP K p
inst✝ : CharP L p
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
hp : Nat.Prime p
⊢ Nonempty (K ≃+* L)

tactic: exact ⟨ringEquivOfCardinalEqOfCharP p hK hKL⟩
state_before: case a.inl
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
inst✝¹ : CharP K p
inst✝ : CharP L p
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
hp : Nat.Prime p
this : Fact (Nat.Prime p)
⊢ Nonempty (K ≃+* L)

tactic: simp only [hp] at *
state_before: case a.inr
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
inst✝¹ : CharP K p
inst✝ : CharP L p
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
hp : p = 0
⊢ Nonempty (K ≃+* L)

tactic: letI : CharZero K := CharP.charP_to_charZero K
state_before: case a.inr
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
inst✝¹ : CharP K 0
inst✝ : CharP L 0
hp : True
⊢ Nonempty (K ≃+* L)

tactic: letI : CharZero L := CharP.charP_to_charZero L
state_before: case a.inr
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
inst✝¹ : CharP K 0
inst✝ : CharP L 0
hp : True
this : CharZero K := CharP.charP_to_charZero K
⊢ Nonempty (K ≃+* L)

tactic: exact ⟨ringEquivOfCardinalEqOfCharZero hK hKL⟩
state_before: case a.inr
K L : Type
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : IsAlgClosed K
inst✝² : IsAlgClosed L
p : ℕ
hK : ℵ₀ < (#K)
hKL : (#K) = (#L)
inst✝¹ : CharP K 0
inst✝ : CharP L 0
hp : True
this✝ : CharZero K := CharP.charP_to_charZero K
this : CharZero L := CharP.charP_to_charZero L
⊢ Nonempty (K ≃+* L)
Theorem: max_sub_min_eq_abs
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [abs_sub_comm]
state_before: α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ max a b - min a b = abs (b - a)

tactic: exact max_sub_min_eq_abs' _ _
state_before: α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ max a b - min a b = abs (a - b)
Theorem: OrderMonoidHom.cancel_right
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: congr
state_before: F : Type ?u.90647
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.90659
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g : α →*o β
g₁ g₂ : β →*o γ
f : α →*o β
hf : Surjective ↑f
x✝ : g₁ = g₂
⊢ comp g₁ f = comp g₂ f