Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | goals listlengths 0 224 | goals_before listlengths 0 220 |
|---|---|---|---|---|---|---|---|
import Mathlib.Algebra.Field.Basic
import Mathlib.Algebra.GroupWithZero.Units.Equiv
import Mathlib.Algebra.Order.Field.Defs
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Order.Bounds.OrderIso
import Mathlib.Tactic.Positivity.Core
#align_import algebra.order.field.basic from "leanprover-community/mathlib"@"8477... | Mathlib/Algebra/Order/Field/Basic.lean | 99 | 101 | theorem inv_mul_le_iff (h : 0 < b) : bβ»ΒΉ * a β€ c β a β€ b * c := by |
rw [inv_eq_one_div, mul_comm, β div_eq_mul_one_div]
exact div_le_iff' h
| [
" a β€ b / c β c * a β€ b",
" a = a / b * b",
" c * b / b = c",
" a / b β€ c β a β€ b * c",
" a / b β€ c β a / c β€ b",
" a < b / c β c * a < b",
" b / c < a β b < c * a",
" a / b < c β a / c < b",
" bβ»ΒΉ * a β€ c β a β€ b * c"
] | [
" a β€ b / c β c * a β€ b",
" a = a / b * b",
" c * b / b = c",
" a / b β€ c β a β€ b * c",
" a / b β€ c β a / c β€ b",
" a < b / c β c * a < b",
" b / c < a β b < c * a",
" a / b < c β a / c < b"
] |
import Mathlib.Analysis.Convex.Between
import Mathlib.Analysis.Normed.Group.AddTorsor
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic
import Mathlib.Analysis.NormedSpace.AffineIsometry
#align_import geometry.euclidean.angle.unoriented.affine from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f... | Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean | 50 | 57 | theorem continuousAt_angle {x : P Γ P Γ P} (hx12 : x.1 β x.2.1) (hx32 : x.2.2 β x.2.1) :
ContinuousAt (fun y : P Γ P Γ P => β y.1 y.2.1 y.2.2) x := by |
let f : P Γ P Γ P β V Γ V := fun y => (y.1 -α΅₯ y.2.1, y.2.2 -α΅₯ y.2.1)
have hf1 : (f x).1 β 0 := by simp [hx12]
have hf2 : (f x).2 β 0 := by simp [hx32]
exact (InnerProductGeometry.continuousAt_angle hf1 hf2).comp
((continuous_fst.vsub continuous_snd.fst).prod_mk
(continuous_snd.snd.vsub continuous_snd... | [
" ContinuousAt (fun y => β y.1 y.2.1 y.2.2) x",
" (f x).1 β 0",
" (f x).2 β 0"
] | [] |
import Mathlib.Analysis.Normed.Group.Hom
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.NormedSpace.LinearIsometry
import Mathlib.Algebra.Star.SelfAdjoint
import Mathlib.Algebra.Star.Subalgebra
import Mathlib.Algebra.Star.Unitary
import Mathlib.Topology.Algebra.Module.Star
#align_import analysis.no... | Mathlib/Analysis/NormedSpace/Star/Basic.lean | 203 | 205 | theorem norm_one [Nontrivial E] : β(1 : E)β = 1 := by |
have : 0 < β(1 : E)β := norm_pos_iff.mpr one_ne_zero
rw [β mul_left_inj' this.ne', β norm_star_mul_self, mul_one, star_one, one_mul]
| [
" βxβ * xβ = βxβ * βxβ",
" β1β = 1"
] | [
" βxβ * xβ = βxβ * βxβ"
] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.RingTheory.IntegralClosure
import Mathlib.RingTheory.Polynomial.IntegralNormalization
#align_import ring_theory.algebraic from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
universe u v w
open scoped Classical
open Polynomi... | Mathlib/RingTheory/Algebraic.lean | 78 | 80 | theorem Algebra.isAlgebraic_iff : Algebra.IsAlgebraic R A β (β€ : Subalgebra R A).IsAlgebraic := by |
delta Subalgebra.IsAlgebraic
simp only [Algebra.isAlgebraic_def, Algebra.mem_top, forall_prop_of_true, iff_self_iff]
| [
" S.IsAlgebraic β Algebra.IsAlgebraic R β₯S",
" (β x β S, _root_.IsAlgebraic R x) β Algebra.IsAlgebraic R β₯S",
" (β (x : β₯S), _root_.IsAlgebraic R βx) β β (x : β₯S), _root_.IsAlgebraic R x",
" (aeval βx) p = 0 β (aeval x) p = 0",
"R : Type u\nA : Type v\ninstβΒ² : CommRing R\ninstβΒΉ : Ring A\ninstβ : Algebra R... | [
" S.IsAlgebraic β Algebra.IsAlgebraic R β₯S",
" (β x β S, _root_.IsAlgebraic R x) β Algebra.IsAlgebraic R β₯S",
" (β (x : β₯S), _root_.IsAlgebraic R βx) β β (x : β₯S), _root_.IsAlgebraic R x",
" (aeval βx) p = 0 β (aeval x) p = 0",
"R : Type u\nA : Type v\ninstβΒ² : CommRing R\ninstβΒΉ : Ring A\ninstβ : Algebra R... |
import Mathlib.Computability.Halting
import Mathlib.Computability.TuringMachine
import Mathlib.Data.Num.Lemmas
import Mathlib.Tactic.DeriveFintype
#align_import computability.tm_to_partrec from "leanprover-community/mathlib"@"6155d4351090a6fad236e3d2e4e0e4e7342668e8"
open Function (update)
open Relation
namespa... | Mathlib/Computability/TMToPartrec.lean | 143 | 143 | theorem succ_eval : succ.eval = fun v => pure [v.headI.succ] := by | simp [eval]
| [
" zero'.eval = fun v => pure (0 :: v)",
" succ.eval = fun v => pure [v.headI.succ]"
] | [
" zero'.eval = fun v => pure (0 :: v)"
] |
import Mathlib.Data.Matroid.Restrict
variable {Ξ± : Type*} {M : Matroid Ξ±} {E B I X R J : Set Ξ±}
namespace Matroid
open Set
section EmptyOn
def emptyOn (Ξ± : Type*) : Matroid Ξ± where
E := β
Base := (Β· = β
)
Indep := (Β· = β
)
indep_iff' := by simp [subset_empty_iff]
exists_base := β¨β
, rflβ©
base_exchange... | Mathlib/Data/Matroid/Constructions.lean | 67 | 69 | theorem eq_emptyOn_or_nonempty (M : Matroid Ξ±) : M = emptyOn Ξ± β¨ Matroid.Nonempty M := by |
rw [β ground_eq_empty_iff]
exact M.E.eq_empty_or_nonempty.elim Or.inl (fun h β¦ Or.inr β¨hβ©)
| [
" β β¦I : Set Ξ±β¦, (fun x => x = β
) I β β B, (fun x => x = β
) B β§ I β B",
" ExchangeProperty fun x => x = β
",
" (fun x => x = β
) Yβ β β a β β
\\ Yβ, β b β Yβ \\ β
, (fun x => x = β
) (insert b (β
\\ {a}))",
" β X β β
, ExistsMaximalSubsetProperty (fun x => x = β
) X",
" (maximals (fun x x_1 => x β x_1) {Y | (fun ... | [
" β β¦I : Set Ξ±β¦, (fun x => x = β
) I β β B, (fun x => x = β
) B β§ I β B",
" ExchangeProperty fun x => x = β
",
" (fun x => x = β
) Yβ β β a β β
\\ Yβ, β b β Yβ \\ β
, (fun x => x = β
) (insert b (β
\\ {a}))",
" β X β β
, ExistsMaximalSubsetProperty (fun x => x = β
) X",
" (maximals (fun x x_1 => x β x_1) {Y | (fun ... |
import Mathlib.Data.List.Basic
#align_import data.bool.all_any from "leanprover-community/mathlib"@"5a3e819569b0f12cbec59d740a2613018e7b8eec"
variable {Ξ± : Type*} {p : Ξ± β Prop} [DecidablePred p] {l : List Ξ±} {a : Ξ±}
namespace List
-- Porting note: in Batteries
#align list.all_nil List.all_nil
#align list.all_... | Mathlib/Data/Bool/AllAny.lean | 48 | 48 | theorem any_iff_exists_prop : (any l fun a => p a) β β a β l, p a := by | simp [any_iff_exists]
| [
" l.all p = true β β (a : Ξ±), a β l β p a = true",
" [].all p = true β β (a : Ξ±), a β [] β p a = true",
" (a :: l).all p = true β β (a_1 : Ξ±), a_1 β a :: l β p a_1 = true",
" (l.all fun a => decide (p a)) = true β β (a : Ξ±), a β l β p a",
" l.any p = true β β a, a β l β§ p a = true",
" [].any p = true β β ... | [
" l.all p = true β β (a : Ξ±), a β l β p a = true",
" [].all p = true β β (a : Ξ±), a β [] β p a = true",
" (a :: l).all p = true β β (a_1 : Ξ±), a_1 β a :: l β p a_1 = true",
" (l.all fun a => decide (p a)) = true β β (a : Ξ±), a β l β p a",
" l.any p = true β β a, a β l β§ p a = true",
" [].any p = true β β ... |
import Aesop
import Mathlib.Algebra.Group.Defs
import Mathlib.Data.Nat.Defs
import Mathlib.Data.Int.Defs
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Cases
import Mathlib.Tactic.SimpRw
import Mathlib.Tactic.SplitIfs
#align_import algebra.group.basic from "leanprover-community/mathlib"@"a07d750983b94c530a... | Mathlib/Algebra/Group/Basic.lean | 474 | 474 | theorem mul_div (a b c : G) : a * (b / c) = a * b / c := by | simp only [mul_assoc, div_eq_mul_inv]
| [
" xβ»ΒΉ = 1 / x",
" x * (1 / y) = x / y",
" a * b / c = a * (b / c)",
" a * (b / c) = a * b / c"
] | [
" xβ»ΒΉ = 1 / x",
" x * (1 / y) = x / y",
" a * b / c = a * (b / c)"
] |
import Mathlib.Data.Nat.Factorial.Basic
import Mathlib.Order.Monotone.Basic
#align_import data.nat.choose.basic from "leanprover-community/mathlib"@"2f3994e1b117b1e1da49bcfb67334f33460c3ce4"
open Nat
namespace Nat
def choose : β β β β β
| _, 0 => 1
| 0, _ + 1 => 0
| n + 1, k + 1 => choose n k + choose n ... | Mathlib/Data/Nat/Choose/Basic.lean | 93 | 95 | theorem triangle_succ (n : β) : (n + 1) * (n + 1 - 1) / 2 = n * (n - 1) / 2 + n := by |
rw [β add_mul_div_left, Nat.mul_comm 2 n, β Nat.mul_add, Nat.add_sub_cancel, Nat.mul_comm]
cases n <;> rfl; apply zero_lt_succ
| [
" n.choose 0 = 1",
" choose 0 0 = 1",
" (nβ + 1).choose 0 = 1",
" (n + 1).choose (k + 1) = 0",
" n.choose n = 1",
" (nβ + 1).choose (nβ + 1) = 1",
" n.choose 1 = n",
" choose 0 1 = 0",
" (nβ + 1).choose 1 = nβ + 1",
" (n + 1) * (n + 1 - 1) / 2 = n * (n - 1) / 2 + n",
" n * (n + 1) / 2 = n * (n -... | [
" n.choose 0 = 1",
" choose 0 0 = 1",
" (nβ + 1).choose 0 = 1",
" (n + 1).choose (k + 1) = 0",
" n.choose n = 1",
" (nβ + 1).choose (nβ + 1) = 1",
" n.choose 1 = n",
" choose 0 1 = 0",
" (nβ + 1).choose 1 = nβ + 1"
] |
import Mathlib.LinearAlgebra.Matrix.DotProduct
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.Diagonal
#align_import data.matrix.rank from "leanprover-community/mathlib"@"17219820a8aa8abe85adf5dfde19af1dd1bd8ae7"
open Matrix
namespace Matrix
open FiniteDimensional
variable {l m n ... | Mathlib/Data/Matrix/Rank.lean | 89 | 93 | theorem rank_unit [StrongRankCondition R] [DecidableEq n] (A : (Matrix n n R)Λ£) :
(A : Matrix n n R).rank = Fintype.card n := by |
apply le_antisymm (rank_le_card_width (A : Matrix n n R)) _
have := rank_mul_le_left (A : Matrix n n R) (βAβ»ΒΉ : Matrix n n R)
rwa [β Units.val_mul, mul_inv_self, Units.val_one, rank_one] at this
| [
" rank 1 = Fintype.card n",
" rank 0 = 0",
" A.rank β€ Fintype.card n",
" (A * B).rank β€ A.rank",
" finrank R β₯(LinearMap.range (A.mulVecLin ββ B.mulVecLin)) β€ finrank R β₯(LinearMap.range A.mulVecLin)",
" (A * B).rank β€ B.rank",
" finrank R β₯(LinearMap.range (A.mulVecLin ββ B.mulVecLin)) β€ finrank R β₯(Li... | [
" rank 1 = Fintype.card n",
" rank 0 = 0",
" A.rank β€ Fintype.card n",
" (A * B).rank β€ A.rank",
" finrank R β₯(LinearMap.range (A.mulVecLin ββ B.mulVecLin)) β€ finrank R β₯(LinearMap.range A.mulVecLin)",
" (A * B).rank β€ B.rank",
" finrank R β₯(LinearMap.range (A.mulVecLin ββ B.mulVecLin)) β€ finrank R β₯(Li... |
import Mathlib.Algebra.Module.LinearMap.Basic
import Mathlib.LinearAlgebra.Basic
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.BilinearMap
#align_import linear_algebra.sesquilinear_form from "leanprover-community/mathlib"@"87c54600fe3cdc7d32ff5b50873ac724d86aef8d"
variable {R Rβ Rβ Rβ M Mβ Mβ Mβ... | Mathlib/LinearAlgebra/SesquilinearForm.lean | 91 | 98 | theorem isOrthoα΅’_flip (B : Mβ βββ[Iβ] Mβ βββ[Iβ'] M) {v : n β Mβ} :
B.IsOrthoα΅’ v β B.flip.IsOrthoα΅’ v := by |
simp_rw [isOrthoα΅’_def]
constructor <;> intro h i j hij
Β· rw [flip_apply]
exact h j i (Ne.symm hij)
simp_rw [flip_apply] at h
exact h j i (Ne.symm hij)
| [
" B.IsOrtho 0 x",
" (B 0) x = 0",
" B.IsOrtho x y β B.flip.IsOrtho y x",
" B.IsOrthoα΅’ v β B.flip.IsOrthoα΅’ v",
" (β (i j : n), i β j β (B (v i)) (v j) = 0) β β (i j : n), i β j β (B.flip (v i)) (v j) = 0",
" (β (i j : n), i β j β (B (v i)) (v j) = 0) β β (i j : n), i β j β (B.flip (v i)) (v j) = 0",
" (β... | [
" B.IsOrtho 0 x",
" (B 0) x = 0",
" B.IsOrtho x y β B.flip.IsOrtho y x"
] |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Hom.Defs
import Mathlib.Algebra.GroupWithZero.NeZero
import Mathlib.Algebra.Opposites
import Mathlib.Algebra.Ring.Defs
#align_import algebra.ring.basic from "leanprover-community/mathlib"@"2ed7e4aec72395b6a7c3ac4ac7873a7a43ead17c"
variable {R : Type*}... | Mathlib/Algebra/Ring/Basic.lean | 112 | 113 | theorem inv_neg' (a : Ξ±) : (-a)β»ΒΉ = -aβ»ΒΉ := by |
rw [eq_comm, eq_inv_iff_mul_eq_one, neg_mul, mul_neg, neg_neg, mul_left_inv]
| [
" (-a)β»ΒΉ = -aβ»ΒΉ"
] | [] |
import Mathlib.RingTheory.Localization.Basic
#align_import ring_theory.localization.integer from "leanprover-community/mathlib"@"9556784a5b84697562e9c6acb40500d4a82e675a"
variable {R : Type*} [CommSemiring R] {M : Submonoid R} {S : Type*} [CommSemiring S]
variable [Algebra R S] {P : Type*} [CommSemiring P]
open ... | Mathlib/RingTheory/Localization/Integer.lean | 85 | 87 | theorem exists_integer_multiple (a : S) : β b : M, IsInteger R ((b : R) β’ a) := by |
simp_rw [Algebra.smul_def, mul_comm _ a]
apply exists_integer_multiple'
| [
" IsInteger R (a β’ b)",
" (algebraMap R S) (a * b') = a β’ b",
" β b, IsInteger R (βb β’ a)",
" β b, IsInteger R (a * (algebraMap R S) βb)"
] | [
" IsInteger R (a β’ b)",
" (algebraMap R S) (a * b') = a β’ b"
] |
import Mathlib.Algebra.Order.Monoid.Unbundled.Basic
#align_import algebra.order.monoid.min_max from "leanprover-community/mathlib"@"de87d5053a9fe5cbde723172c0fb7e27e7436473"
open Function
variable {Ξ± Ξ² : Type*}
section CovariantClassMulLe
variable [LinearOrder Ξ±]
section Mul
variable [Mul Ξ±]
@[to_additive... | Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean | 108 | 112 | theorem lt_or_le_of_mul_le_mul [CovariantClass Ξ± Ξ± (Β· * Β·) (Β· < Β·)]
[CovariantClass Ξ± Ξ± (Function.swap (Β· * Β·)) (Β· β€ Β·)] {aβ aβ bβ bβ : Ξ±} :
aβ * bβ β€ aβ * bβ β aβ < aβ β¨ bβ β€ bβ := by |
contrapose!
exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
| [
" aβ * bβ < aβ * bβ β aβ < aβ β¨ bβ < bβ",
" aβ β€ aβ β§ bβ β€ bβ β aβ * bβ β€ aβ * bβ",
" aβ * bβ β€ aβ * bβ β aβ β€ aβ β¨ bβ < bβ",
" aβ < aβ β§ bβ β€ bβ β aβ * bβ < aβ * bβ",
" aβ * bβ β€ aβ * bβ β aβ < aβ β¨ bβ β€ bβ",
" aβ β€ aβ β§ bβ < bβ β aβ * bβ < aβ * bβ"
] | [
" aβ * bβ < aβ * bβ β aβ < aβ β¨ bβ < bβ",
" aβ β€ aβ β§ bβ β€ bβ β aβ * bβ β€ aβ * bβ",
" aβ * bβ β€ aβ * bβ β aβ β€ aβ β¨ bβ < bβ",
" aβ < aβ β§ bβ β€ bβ β aβ * bβ < aβ * bβ"
] |
import Mathlib.MeasureTheory.Integral.Lebesgue
open Set hiding restrict restrict_apply
open Filter ENNReal NNReal MeasureTheory.Measure
namespace MeasureTheory
variable {Ξ± : Type*} {m0 : MeasurableSpace Ξ±} {ΞΌ : Measure Ξ±}
noncomputable
def Measure.withDensity {m : MeasurableSpace Ξ±} (ΞΌ : Measure Ξ±) (f : Ξ± β ββ₯... | Mathlib/MeasureTheory/Measure/WithDensity.lean | 97 | 102 | theorem withDensity_add_left {f : Ξ± β ββ₯0β} (hf : Measurable f) (g : Ξ± β ββ₯0β) :
ΞΌ.withDensity (f + g) = ΞΌ.withDensity f + ΞΌ.withDensity g := by |
refine Measure.ext fun s hs => ?_
rw [withDensity_apply _ hs, Measure.add_apply, withDensity_apply _ hs, withDensity_apply _ hs,
β lintegral_add_left hf]
simp only [Pi.add_apply]
| [
" (fun s x => β«β» (a : Ξ±) in s, f a βΞΌ) β
β― = 0",
" β«β» (a : Ξ±) in s, f a βΞΌ β€ (ΞΌ.withDensity f) s",
" (ΞΌ.withDensity f) s = β«β» (a : Ξ±) in s, f a βΞΌ",
" (ΞΌ.withDensity f) s β€ β«β» (a : Ξ±) in s, f a βΞΌ",
" β«β» (a : Ξ±) in t, f a βΞΌ = β«β» (a : Ξ±) in s, f a βΞΌ",
" ΞΌ.restrict t = ΞΌ.restrict s",
" withDensity 0 f =... | [
" (fun s x => β«β» (a : Ξ±) in s, f a βΞΌ) β
β― = 0",
" β«β» (a : Ξ±) in s, f a βΞΌ β€ (ΞΌ.withDensity f) s",
" (ΞΌ.withDensity f) s = β«β» (a : Ξ±) in s, f a βΞΌ",
" (ΞΌ.withDensity f) s β€ β«β» (a : Ξ±) in s, f a βΞΌ",
" β«β» (a : Ξ±) in t, f a βΞΌ = β«β» (a : Ξ±) in s, f a βΞΌ",
" ΞΌ.restrict t = ΞΌ.restrict s",
" withDensity 0 f =... |
import Mathlib.RingTheory.Ideal.Maps
import Mathlib.Topology.Algebra.Nonarchimedean.Bases
import Mathlib.Topology.Algebra.UniformRing
#align_import topology.algebra.nonarchimedean.adic_topology from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
variable {R : Type*} [CommRing R]
open S... | Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean | 116 | 126 | theorem adic_module_basis :
I.ringFilterBasis.SubmodulesBasis fun n : β => I ^ n β’ (β€ : Submodule R M) :=
{ inter := fun i j =>
β¨max i j,
le_inf_iff.mpr
β¨smul_mono_left <| pow_le_pow_right (le_max_left i j),
smul_mono_left <| pow_le_pow_right (le_max_right i j)β©β©
smul := fu... | simpa [(I ^ i).mul_top] using a_in
exact smul_mem_smul a_in mem_topβ© }
| [
" β (i j : β), β k, I ^ k β’ β€ β€ I ^ i β’ β€ β I ^ j β’ β€",
" β (i j : β), β k, I ^ k β€ I ^ i β§ I ^ k β€ I ^ j",
" β k, I ^ k β€ I ^ i β§ I ^ k β€ I ^ j",
" β (a : R) (i : β), β j, a β’ I ^ j β’ β€ β€ I ^ i β’ β€",
" β (a : R) (i : β), β j, a β’ I ^ j β€ I ^ i",
" β j, r β’ I ^ j β€ I ^ n",
" r β’ I ^ n β€ I ^ n",
" (Dis... | [
" β (i j : β), β k, I ^ k β’ β€ β€ I ^ i β’ β€ β I ^ j β’ β€",
" β (i j : β), β k, I ^ k β€ I ^ i β§ I ^ k β€ I ^ j",
" β k, I ^ k β€ I ^ i β§ I ^ k β€ I ^ j",
" β (a : R) (i : β), β j, a β’ I ^ j β’ β€ β€ I ^ i β’ β€",
" β (a : R) (i : β), β j, a β’ I ^ j β€ I ^ i",
" β j, r β’ I ^ j β€ I ^ n",
" r β’ I ^ n β€ I ^ n",
" (Dis... |
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27ddac1835a3852b9"
namespace MeasureTheory
open Filter
open scoped ENNReal
variable {Ξ± E : Type*} {m m0 : MeasurableSpace Ξ±} {p : ββ₯0β} {q : β} {ΞΌ :... | Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean | 68 | 71 | theorem snorm_trim_ae (hm : m β€ m0) {f : Ξ± β E} (hf : AEStronglyMeasurable f (ΞΌ.trim hm)) :
snorm f p (ΞΌ.trim hm) = snorm f p ΞΌ := by |
rw [snorm_congr_ae hf.ae_eq_mk, snorm_congr_ae (ae_eq_of_ae_eq_trim hf.ae_eq_mk)]
exact snorm_trim hm hf.stronglyMeasurable_mk
| [
" snorm' f q (ΞΌ.trim hm) = snorm' f q ΞΌ",
" (β«β» (a : Ξ±), ββf aββ ^ q βΞΌ.trim hm) ^ (1 / q) = (β«β» (a : Ξ±), ββf aββ ^ q βΞΌ) ^ (1 / q)",
" β«β» (a : Ξ±), ββf aββ ^ q βΞΌ.trim hm = β«β» (a : Ξ±), ββf aββ ^ q βΞΌ",
" Measurable fun a => ββf aββ ^ q",
" Measurable fun a => βf aββ",
" StronglyMeasurable fun a => βf aββ"... | [
" snorm' f q (ΞΌ.trim hm) = snorm' f q ΞΌ",
" (β«β» (a : Ξ±), ββf aββ ^ q βΞΌ.trim hm) ^ (1 / q) = (β«β» (a : Ξ±), ββf aββ ^ q βΞΌ) ^ (1 / q)",
" β«β» (a : Ξ±), ββf aββ ^ q βΞΌ.trim hm = β«β» (a : Ξ±), ββf aββ ^ q βΞΌ",
" Measurable fun a => ββf aββ ^ q",
" Measurable fun a => βf aββ",
" StronglyMeasurable fun a => βf aββ"... |
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Int.GCD
import Mathlib.RingTheory.Coprime.Basic
#align_import ring_theory.coprime.lemmas from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
universe u v
section RelPrime
variable {Ξ± I} [Comm... | Mathlib/RingTheory/Coprime/Lemmas.lean | 250 | 251 | theorem IsRelPrime.prod_right_iff : IsRelPrime x (β i β t, s i) β β i β t, IsRelPrime x (s i) := by |
simpa only [isRelPrime_comm] using IsRelPrime.prod_left_iff (Ξ± := Ξ±)
| [
" (β i β t, IsRelPrime (s i) x) β IsRelPrime (β i β t, s i) x",
" IsRelPrime (β i β insert b t, s i) x",
" IsRelPrime (s b * β x β t, s x) x",
" (β i β t, IsRelPrime x (s i)) β IsRelPrime x (β i β t, s i)",
" IsRelPrime (β i β t, s i) x β β i β t, IsRelPrime (s i) x",
" xβ β β
β IsRelPrime (s xβ) x",
" ... | [
" (β i β t, IsRelPrime (s i) x) β IsRelPrime (β i β t, s i) x",
" IsRelPrime (β i β insert b t, s i) x",
" IsRelPrime (s b * β x β t, s x) x",
" (β i β t, IsRelPrime x (s i)) β IsRelPrime x (β i β t, s i)",
" IsRelPrime (β i β t, s i) x β β i β t, IsRelPrime (s i) x",
" xβ β β
β IsRelPrime (s xβ) x",
" ... |
import Mathlib.Topology.MetricSpace.ProperSpace
import Mathlib.Topology.MetricSpace.Cauchy
open Set Filter Bornology
open scoped ENNReal Uniformity Topology Pointwise
universe u v w
variable {Ξ± : Type u} {Ξ² : Type v} {X ΞΉ : Type*}
variable [PseudoMetricSpace Ξ±]
namespace Metric
#align metric.bounded Bornology.I... | Mathlib/Topology/MetricSpace/Bounded.lean | 137 | 139 | theorem tendsto_dist_right_atTop_iff (c : Ξ±) {f : Ξ² β Ξ±} {l : Filter Ξ²} :
Tendsto (fun x β¦ dist (f x) c) l atTop β Tendsto f l (cobounded Ξ±) := by |
rw [β comap_dist_right_atTop c, tendsto_comap_iff, Function.comp_def]
| [
" (β r, xβ β closedBall c r) β β i, True β§ (closedBall c i)αΆ β xβαΆ",
" (β r, xβ β ball c r) β β i, True β§ (ball c i)αΆ β xβαΆ",
" (cobounded Ξ±).HasBasis (fun x => True) fun i => (fun x => dist x c) β»ΒΉ' Ici i",
" comap (dist c) atTop = cobounded Ξ±",
" Tendsto (fun x => dist (f x) c) l atTop β Tendsto f l (cobo... | [
" (β r, xβ β closedBall c r) β β i, True β§ (closedBall c i)αΆ β xβαΆ",
" (β r, xβ β ball c r) β β i, True β§ (ball c i)αΆ β xβαΆ",
" (cobounded Ξ±).HasBasis (fun x => True) fun i => (fun x => dist x c) β»ΒΉ' Ici i",
" comap (dist c) atTop = cobounded Ξ±"
] |
import Mathlib.RingTheory.PowerSeries.Trunc
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.RingTheory.Derivation.Basic
namespace PowerSeries
open Polynomial Derivation Nat
section CommutativeSemiring
variable {R} [CommSemiring R]
noncomputable def derivativeFun (f : Rβ¦Xβ§) : Rβ¦Xβ§ := mk fun n β¦ coef... | Mathlib/RingTheory/PowerSeries/Derivative.lean | 87 | 88 | theorem derivativeFun_one : derivativeFun (1 : Rβ¦Xβ§) = 0 := by |
rw [β map_one (C R), derivativeFun_C (1 : R)]
| [
" (coeff R n) f.derivativeFun = (coeff R (n + 1)) f * (βn + 1)",
" (βf).derivativeFun = β(derivative f)",
" (coeff R nβ) (βf).derivativeFun = (coeff R nβ) β(derivative f)",
" (f + g).derivativeFun = f.derivativeFun + g.derivativeFun",
" (coeff R nβ) (f + g).derivativeFun = (coeff R nβ) (f.derivativeFun + g.... | [
" (coeff R n) f.derivativeFun = (coeff R (n + 1)) f * (βn + 1)",
" (βf).derivativeFun = β(derivative f)",
" (coeff R nβ) (βf).derivativeFun = (coeff R nβ) β(derivative f)",
" (f + g).derivativeFun = f.derivativeFun + g.derivativeFun",
" (coeff R nβ) (f + g).derivativeFun = (coeff R nβ) (f.derivativeFun + g.... |
import Mathlib.Init.Logic
import Mathlib.Tactic.AdaptationNote
import Mathlib.Tactic.Coe
set_option autoImplicit true
-- We align Lean 3 lemmas with lemmas in `Init.SimpLemmas` in Lean 4.
#align band_self Bool.and_self
#align band_tt Bool.and_true
#align band_ff Bool.and_false
#align tt_band Bool.true_and
#align f... | Mathlib/Init/Data/Bool/Lemmas.lean | 76 | 76 | theorem not_eq_true_eq_eq_false (a : Bool) : (not a = true) = (a = false) := by | cases a <;> simp
| [
" Β¬true = false",
" Β¬false = true",
" (Β¬b = true) = (b = false)",
" (Β¬b = false) = (b = true)",
" ((a && b) = true) = (a = true β§ b = true)",
" ((a || b) = true) = (a = true β¨ b = true)",
" ((!a) = true) = (a = false)",
" ((!false) = true) = (false = false)",
" ((!true) = true) = (true = false)"
] | [
" Β¬true = false",
" Β¬false = true",
" (Β¬b = true) = (b = false)",
" (Β¬b = false) = (b = true)",
" ((a && b) = true) = (a = true β§ b = true)",
" ((a || b) = true) = (a = true β¨ b = true)"
] |
import Mathlib.Geometry.Manifold.ContMDiff.Defs
open Set Filter Function
open scoped Topology Manifold
variable {π : Type*} [NontriviallyNormedField π]
-- declare a smooth manifold `M` over the pair `(E, H)`.
{E : Type*}
[NormedAddCommGroup E] [NormedSpace π E] {H : Type*} [TopologicalSpace H]
(I : Mode... | Mathlib/Geometry/Manifold/ContMDiff/Basic.lean | 52 | 77 | theorem ContMDiffWithinAt.comp {t : Set M'} {g : M' β M''} (x : M)
(hg : ContMDiffWithinAt I' I'' n g t (f x)) (hf : ContMDiffWithinAt I I' n f s x)
(st : MapsTo f s t) : ContMDiffWithinAt I I'' n (g β f) s x := by |
rw [contMDiffWithinAt_iff] at hg hf β’
refine β¨hg.1.comp hf.1 st, ?_β©
set e := extChartAt I x
set e' := extChartAt I' (f x)
have : e' (f x) = (writtenInExtChartAt I I' x f) (e x) := by simp only [e, e', mfld_simps]
rw [this] at hg
have A : βαΆ y in π[e.symm β»ΒΉ' s β© range I] e x, f (e.symm y) β t β§ f (e.sy... | [
" ContMDiffWithinAt I I'' n (g β f) s x",
" ContinuousWithinAt (g β f) s x β§\n ContDiffWithinAt π n (β(extChartAt I'' ((g β f) x)) β (g β f) β β(extChartAt I x).symm)\n (β(extChartAt I x).symm β»ΒΉ' s β© range βI) (β(extChartAt I x) x)",
" ContDiffWithinAt π n (β(extChartAt I'' ((g β f) x)) β (g β f) β β... | [] |
import Mathlib.MeasureTheory.MeasurableSpace.Defs
import Mathlib.SetTheory.Cardinal.Cofinality
import Mathlib.SetTheory.Cardinal.Continuum
#align_import measure_theory.card_measurable_space from "leanprover-community/mathlib"@"f2b108e8e97ba393f22bf794989984ddcc1da89b"
universe u
variable {Ξ± : Type u}
open Cardi... | Mathlib/MeasureTheory/MeasurableSpace/Card.lean | 62 | 65 | theorem empty_mem_generateMeasurableRec (s : Set (Set Ξ±)) (i : Οβ) :
β
β generateMeasurableRec s i := by |
unfold generateMeasurableRec
exact mem_union_left _ (mem_union_left _ (mem_union_right _ (mem_singleton β
)))
| [
" (invImage (fun x => x) (hasWellFoundedOut (aleph 1).ord)).1 (βj) aβ",
" s β generateMeasurableRec s i",
" s β\n let i := i;\n let S := β j, generateMeasurableRec s βj;\n s βͺ {β
} βͺ compl '' S βͺ range fun f => β n, β(f n)",
" s β s",
" β
β generateMeasurableRec s i",
" β
β\n let i := i;\n l... | [
" (invImage (fun x => x) (hasWellFoundedOut (aleph 1).ord)).1 (βj) aβ",
" s β generateMeasurableRec s i",
" s β\n let i := i;\n let S := β j, generateMeasurableRec s βj;\n s βͺ {β
} βͺ compl '' S βͺ range fun f => β n, β(f n)",
" s β s"
] |
import Mathlib.Order.PartialSups
#align_import order.disjointed from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
variable {Ξ± Ξ² : Type*}
section GeneralizedBooleanAlgebra
variable [GeneralizedBooleanAlgebra Ξ±]
def disjointed (f : β β Ξ±) : β β Ξ±
| 0 => f 0
| n + 1 => f (n + 1) ... | Mathlib/Order/Disjointed.lean | 114 | 118 | theorem partialSups_disjointed (f : β β Ξ±) : partialSups (disjointed f) = partialSups f := by |
ext n
induction' n with k ih
Β· rw [partialSups_zero, partialSups_zero, disjointed_zero]
Β· rw [partialSups_succ, partialSups_succ, disjointed_succ, ih, sup_sdiff_self_right]
| [
" disjointed β€ id",
" disjointed f n β€ id f n",
" disjointed f 0 β€ id f 0",
" disjointed f (nβ + 1) β€ id f (nβ + 1)",
" Pairwise (Disjoint on disjointed f)",
" Disjoint (disjointed f m) (disjointed f n)",
" Disjoint (disjointed f m) (disjointed f 0)",
" Disjoint (disjointed f m) (disjointed f (nβ + 1)... | [
" disjointed β€ id",
" disjointed f n β€ id f n",
" disjointed f 0 β€ id f 0",
" disjointed f (nβ + 1) β€ id f (nβ + 1)",
" Pairwise (Disjoint on disjointed f)",
" Disjoint (disjointed f m) (disjointed f n)",
" Disjoint (disjointed f m) (disjointed f 0)",
" Disjoint (disjointed f m) (disjointed f (nβ + 1)... |
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.SpecialFunctions.Complex.Circle
import Mathlib.Analysis.InnerProductSpace.l2Space
import Mathlib.MeasureTheory.Function.ContinuousMapDense
import Mathlib.MeasureTheory.Function.L2Space
import Mathlib.MeasureTheory.Group.Integral
import Mathlib.M... | Mathlib/Analysis/Fourier/AddCircle.lean | 132 | 135 | theorem fourier_zero {x : AddCircle T} : fourier 0 x = 1 := by |
induction x using QuotientAddGroup.induction_on'
simp only [fourier_coe_apply]
norm_num
| [
" (fourier n) βx = (2 * βΟ * Complex.I * βn * βx / βT).exp",
" (β2 * βΟ / βT * (βn * βx) * Complex.I).exp = (2 * βΟ * Complex.I * βn * βx / βT).exp",
" (2 * βΟ / βT * (βn * βx) * Complex.I).exp = (2 * βΟ * Complex.I * βn * βx / βT).exp",
" 2 * βΟ / βT * (βn * βx) * Complex.I = 2 * βΟ * Complex.I * βn * βx / β... | [
" (fourier n) βx = (2 * βΟ * Complex.I * βn * βx / βT).exp",
" (β2 * βΟ / βT * (βn * βx) * Complex.I).exp = (2 * βΟ * Complex.I * βn * βx / βT).exp",
" (2 * βΟ / βT * (βn * βx) * Complex.I).exp = (2 * βΟ * Complex.I * βn * βx / βT).exp",
" 2 * βΟ / βT * (βn * βx) * Complex.I = 2 * βΟ * Complex.I * βn * βx / β... |
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.MeasureTheory.Group.Measure
#align_import measure_theory.group.integration from "leanprover-community/mathlib"@"ec247d43814751ffceb33b758e8820df2372bf6f"
namespace MeasureTheory
open Measure TopologicalSpace
open scoped ENNReal
variable {π M Ξ± G E F ... | Mathlib/MeasureTheory/Group/Integral.lean | 40 | 43 | theorem integral_inv_eq_self (f : G β E) (ΞΌ : Measure G) [IsInvInvariant ΞΌ] :
β« x, f xβ»ΒΉ βΞΌ = β« x, f x βΞΌ := by |
have h : MeasurableEmbedding fun x : G => xβ»ΒΉ := (MeasurableEquiv.inv G).measurableEmbedding
rw [β h.integral_map, map_inv_eq_self]
| [
" β« (x : G), f xβ»ΒΉ βΞΌ = β« (x : G), f x βΞΌ"
] | [] |
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.NormedSpace.LinearIsometry
#align_import analysis.normed_space.conformal_linear_map from "leanprover-community/mathlib"@"d1bd9c5df2867c1cb463bc6364446d57bdd9f7f1"
noncomputable section
open Function LinearIsometry ContinuousLinearMap
def IsConf... | Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean | 97 | 100 | theorem ne_zero [Nontrivial M'] {f' : M' βL[R] N} (hf' : IsConformalMap f') : f' β 0 := by |
rintro rfl
rcases exists_ne (0 : M') with β¨a, haβ©
exact ha (hf'.injective rfl)
| [
" ContinuousLinearMap.id R M = 1 β’ LinearIsometry.id.toContinuousLinearMap",
" IsConformalMap (c β’ f)",
" IsConformalMap (c β’ c' β’ li.toContinuousLinearMap)",
" β0 xβ = βxβ",
" IsConformalMap (g.comp f)",
" IsConformalMap (g.comp (cf β’ lif.toContinuousLinearMap))",
" IsConformalMap ((cg β’ lig.toContinuo... | [
" ContinuousLinearMap.id R M = 1 β’ LinearIsometry.id.toContinuousLinearMap",
" IsConformalMap (c β’ f)",
" IsConformalMap (c β’ c' β’ li.toContinuousLinearMap)",
" β0 xβ = βxβ",
" IsConformalMap (g.comp f)",
" IsConformalMap (g.comp (cf β’ lif.toContinuousLinearMap))",
" IsConformalMap ((cg β’ lig.toContinuo... |
import Mathlib.Order.MinMax
import Mathlib.Data.Set.Subsingleton
import Mathlib.Tactic.Says
#align_import data.set.intervals.basic from "leanprover-community/mathlib"@"3ba15165bd6927679be7c22d6091a87337e3cd0c"
open Function
open OrderDual (toDual ofDual)
variable {Ξ± Ξ² : Type*}
namespace Set
section Preorder
v... | Mathlib/Order/Interval/Set/Basic.lean | 191 | 191 | theorem left_mem_Icc : a β Icc a b β a β€ b := by | simp [le_refl]
| [
" Decidable (x β Ioo a b)",
" Decidable (x β Ico a b)",
" Decidable (x β Iio b)",
" Decidable (x β Icc a b)",
" Decidable (x β Iic b)",
" Decidable (x β Ioc a b)",
" Decidable (x β Ici a)",
" Decidable (x β Ioi a)",
" a β Ioo a b β False",
" a β Ico a b β a < b",
" a β Icc a b β a β€ b"
] | [
" Decidable (x β Ioo a b)",
" Decidable (x β Ico a b)",
" Decidable (x β Iio b)",
" Decidable (x β Icc a b)",
" Decidable (x β Iic b)",
" Decidable (x β Ioc a b)",
" Decidable (x β Ici a)",
" Decidable (x β Ioi a)",
" a β Ioo a b β False",
" a β Ico a b β a < b"
] |
import Mathlib.RingTheory.WittVector.Frobenius
import Mathlib.RingTheory.WittVector.Verschiebung
import Mathlib.RingTheory.WittVector.MulP
#align_import ring_theory.witt_vector.identities from "leanprover-community/mathlib"@"0798037604b2d91748f9b43925fb7570a5f3256c"
namespace WittVector
variable {p : β} {R : Typ... | Mathlib/RingTheory/WittVector/Identities.lean | 87 | 87 | theorem coeff_p_one [CharP R p] : (p : π R).coeff 1 = 1 := by | rw [coeff_p, if_pos rfl]
| [
" frobenius (verschiebung x) = x * βp",
" β (n : β), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * βp)",
" verschiebung x = x * βp",
" (βp ^ i).coeff i = 1",
" (βp ^ 0).coeff 0 = 1",
" (βp ^ (i + 1)).coeff (i + 1) = 1",
" (βp ^ i).coeff j = 0",
" (βp ^ 0).coeff j = 0",
" ... | [
" frobenius (verschiebung x) = x * βp",
" β (n : β), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * βp)",
" verschiebung x = x * βp",
" (βp ^ i).coeff i = 1",
" (βp ^ 0).coeff 0 = 1",
" (βp ^ (i + 1)).coeff (i + 1) = 1",
" (βp ^ i).coeff j = 0",
" (βp ^ 0).coeff j = 0",
" ... |
import Mathlib.Topology.MetricSpace.HausdorffDistance
import Mathlib.MeasureTheory.Constructions.BorelSpace.Order
#align_import measure_theory.measure.regular from "leanprover-community/mathlib"@"bf6a01357ff5684b1ebcd0f1a13be314fc82c0bf"
open Set Filter ENNReal Topology NNReal TopologicalSpace
namespace MeasureTh... | Mathlib/MeasureTheory/Measure/Regular.lean | 244 | 252 | theorem map' {Ξ± Ξ²} [MeasurableSpace Ξ±] [MeasurableSpace Ξ²] {ΞΌ : Measure Ξ±} {pa qa : Set Ξ± β Prop}
(H : InnerRegularWRT ΞΌ pa qa) (f : Ξ± βα΅ Ξ²) {pb qb : Set Ξ² β Prop}
(hAB : β U, qb U β qa (f β»ΒΉ' U)) (hAB' : β K, pa K β pb (f '' K)) :
InnerRegularWRT (map f ΞΌ) pb qb := by |
intro U hU r hr
rw [f.map_apply U] at hr
rcases H (hAB U hU) r hr with β¨K, hKU, hKc, hKβ©
refine β¨f '' K, image_subset_iff.2 hKU, hAB' _ hKc, ?_β©
rwa [f.map_apply, f.preimage_image]
| [
" ΞΌ U = β¨ K, β¨ (_ : K β U), β¨ (_ : p K), ΞΌ K",
" r < β¨ K, β¨ (_ : K β U), β¨ (_ : p K), ΞΌ K",
" β K β U, p K β§ ΞΌ U < ΞΌ K + Ξ΅",
" ΞΌ U < ΞΌ β
+ Ξ΅",
" (map f ΞΌ).InnerRegularWRT pb qb",
" β K β U, pb K β§ r < (map f ΞΌ) K",
" r < (map f ΞΌ) (f '' K)",
" (map (βf) ΞΌ).InnerRegularWRT pb qb",
" β K β U, pb K β§ r... | [
" ΞΌ U = β¨ K, β¨ (_ : K β U), β¨ (_ : p K), ΞΌ K",
" r < β¨ K, β¨ (_ : K β U), β¨ (_ : p K), ΞΌ K",
" β K β U, p K β§ ΞΌ U < ΞΌ K + Ξ΅",
" ΞΌ U < ΞΌ β
+ Ξ΅",
" (map f ΞΌ).InnerRegularWRT pb qb",
" β K β U, pb K β§ r < (map f ΞΌ) K",
" r < (map f ΞΌ) (f '' K)"
] |
import Mathlib.RingTheory.WittVector.Frobenius
import Mathlib.RingTheory.WittVector.Verschiebung
import Mathlib.RingTheory.WittVector.MulP
#align_import ring_theory.witt_vector.identities from "leanprover-community/mathlib"@"0798037604b2d91748f9b43925fb7570a5f3256c"
namespace WittVector
variable {p : β} {R : Typ... | Mathlib/RingTheory/WittVector/Identities.lean | 42 | 47 | theorem frobenius_verschiebung (x : π R) : frobenius (verschiebung x) = x * p := by |
have : IsPoly p fun {R} [CommRing R] x β¦ frobenius (verschiebung x) :=
IsPoly.comp (hg := frobenius_isPoly p) (hf := verschiebung_isPoly)
have : IsPoly p fun {R} [CommRing R] x β¦ x * p := mulN_isPoly p p
ghost_calc x
ghost_simp [mul_comm]
| [
" frobenius (verschiebung x) = x * βp",
" β (n : β), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * βp)"
] | [] |
import Mathlib.Data.Rat.Cast.Defs
import Mathlib.Algebra.Field.Basic
#align_import data.rat.cast from "leanprover-community/mathlib"@"acebd8d49928f6ed8920e502a6c90674e75bd441"
namespace Rat
variable {Ξ± : Type*} [DivisionRing Ξ±]
-- Porting note: rewrote proof
@[simp]
theorem cast_inv_nat (n : β) : ((nβ»ΒΉ : β) : Ξ±... | Mathlib/Data/Rat/Cast/Lemmas.lean | 37 | 40 | theorem cast_inv_int (n : β€) : ((nβ»ΒΉ : β) : Ξ±) = (n : Ξ±)β»ΒΉ := by |
cases' n with n n
Β· simp [ofInt_eq_cast, cast_inv_nat]
Β· simp only [ofInt_eq_cast, Int.cast_negSucc, β Nat.cast_succ, cast_neg, inv_neg, cast_inv_nat]
| [
" β(βn)β»ΒΉ = (βn)β»ΒΉ",
" β(β0)β»ΒΉ = (β0)β»ΒΉ",
" β(β(n + 1))β»ΒΉ = (β(n + 1))β»ΒΉ",
" β(β(Int.ofNat n))β»ΒΉ = (β(Int.ofNat n))β»ΒΉ",
" β(β(Int.negSucc n))β»ΒΉ = (β(Int.negSucc n))β»ΒΉ"
] | [
" β(βn)β»ΒΉ = (βn)β»ΒΉ",
" β(β0)β»ΒΉ = (β0)β»ΒΉ",
" β(β(n + 1))β»ΒΉ = (β(n + 1))β»ΒΉ"
] |
import Mathlib.Data.Fin.VecNotation
import Mathlib.Logic.Embedding.Set
#align_import logic.equiv.fin from "leanprover-community/mathlib"@"bd835ef554f37ef9b804f0903089211f89cb370b"
assert_not_exists MonoidWithZero
universe u
variable {m n : β}
def finZeroEquiv : Fin 0 β Empty :=
Equiv.equivEmpty _
#align fin_... | Mathlib/Logic/Equiv/Fin.lean | 126 | 128 | theorem finSuccEquiv'_above {i : Fin (n + 1)} {m : Fin n} (h : i β€ Fin.castSucc m) :
(finSuccEquiv' i) m.succ = some m := by |
rw [β Fin.succAbove_of_le_castSucc _ _ h, finSuccEquiv'_succAbove]
| [
" (fun b => Bool.casesOn b 0 1) (![false, true] 0) = 0 β§ (fun b => Bool.casesOn b 0 1) (![false, true] 1) = 1",
" ![false, true] ((fun b => Bool.casesOn b 0 1) false) = false β§\n ![false, true] ((fun b => Bool.casesOn b 0 1) true) = true",
" (fun f => (f 0, f 1)) β»ΒΉ' s ΓΛ’ t = Set.univ.pi (cons s (cons t finZ... | [
" (fun b => Bool.casesOn b 0 1) (![false, true] 0) = 0 β§ (fun b => Bool.casesOn b 0 1) (![false, true] 1) = 1",
" ![false, true] ((fun b => Bool.casesOn b 0 1) false) = false β§\n ![false, true] ((fun b => Bool.casesOn b 0 1) true) = true",
" (fun f => (f 0, f 1)) β»ΒΉ' s ΓΛ’ t = Set.univ.pi (cons s (cons t finZ... |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 248 | 250 | theorem coprodα΅’_eq_bot_iff' : Filter.coprodα΅’ f = β₯ β (β i, IsEmpty (Ξ± i)) β¨ f = β₯ := by |
simpa only [not_neBot, not_and_or, funext_iff, not_forall, not_exists, not_nonempty_iff]
using coprodα΅’_neBot_iff'.not
| [
" s β Filter.coprodα΅’ f β β (i : ΞΉ), β tβ β f i, eval i β»ΒΉ' tβ β s",
" sαΆ β Filter.coprodα΅’ f β β (i : ΞΉ), (eval i '' s)αΆ β f i",
" (Filter.coprodα΅’ f).NeBot β (β (i : ΞΉ), Nonempty (Ξ± i)) β§ β d, (f d).NeBot",
" (Filter.coprodα΅’ f).NeBot β β d, (f d).NeBot",
" Filter.coprodα΅’ f = β₯ β (β i, IsEmpty (Ξ± i)) β¨ f = β₯"... | [
" s β Filter.coprodα΅’ f β β (i : ΞΉ), β tβ β f i, eval i β»ΒΉ' tβ β s",
" sαΆ β Filter.coprodα΅’ f β β (i : ΞΉ), (eval i '' s)αΆ β f i",
" (Filter.coprodα΅’ f).NeBot β (β (i : ΞΉ), Nonempty (Ξ± i)) β§ β d, (f d).NeBot",
" (Filter.coprodα΅’ f).NeBot β β d, (f d).NeBot"
] |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
| Mathlib/Topology/Order/LeftRight.lean | 111 | 112 | theorem nhds_left_sup_nhds_right (a : Ξ±) : π[β€] a β π[β₯] a = π a := by |
rw [β nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
| [
" π[β€] a β π[β₯] a = π a"
] | [] |
import Mathlib.Data.Complex.Module
import Mathlib.Data.Complex.Order
import Mathlib.Data.Complex.Exponential
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Topology.Algebra.InfiniteSum.Module
import Mathlib.Topology.Instances.RealVectorSpace
#align_import analysis.complex.basic from "leanprover-community/mathlib... | Mathlib/Analysis/Complex/Basic.lean | 137 | 139 | theorem dist_conj_self (z : β) : dist (conj z) z = 2 * |z.im| := by |
rw [dist_of_re_eq (conj_re z), conj_im, dist_comm, Real.dist_eq, sub_neg_eq_add, β two_mul,
_root_.abs_mul, abs_of_pos (zero_lt_two' β)]
| [
" βcexp (βt * I)β = 1",
" rβ < ββxβ β§ ββxβ < rβ",
" βr β’ xβ β€ βrβ * βxβ",
" dist z w = β((z.re - w.re) ^ 2 + (z.im - w.im) ^ 2)",
" dist z w = β((z.re - w.re) * (z.re - w.re) + (z.im - w.im) * (z.im - w.im))",
" dist z w = dist z.im w.im",
" edist z w = edist z.im w.im",
" dist z w = dist z.re w.re",
... | [
" βcexp (βt * I)β = 1",
" rβ < ββxβ β§ ββxβ < rβ",
" βr β’ xβ β€ βrβ * βxβ",
" dist z w = β((z.re - w.re) ^ 2 + (z.im - w.im) ^ 2)",
" dist z w = β((z.re - w.re) * (z.re - w.re) + (z.im - w.im) * (z.im - w.im))",
" dist z w = dist z.im w.im",
" edist z w = edist z.im w.im",
" dist z w = dist z.re w.re",
... |
import Mathlib.Algebra.MvPolynomial.Monad
#align_import data.mv_polynomial.expand from "leanprover-community/mathlib"@"5da451b4c96b4c2e122c0325a7fce17d62ee46c6"
namespace MvPolynomial
variable {Ο Ο R S : Type*} [CommSemiring R] [CommSemiring S]
noncomputable def expand (p : β) : MvPolynomial Ο R ββ[R] MvPolyno... | Mathlib/Algebra/MvPolynomial/Expand.lean | 88 | 92 | theorem rename_comp_expand (f : Ο β Ο) (p : β) :
(rename f).comp (expand p) =
(expand p).comp (rename f : MvPolynomial Ο R ββ[R] MvPolynomial Ο R) := by |
ext1 Ο
simp only [rename_expand, AlgHom.comp_apply]
| [
" (expand 1) f = f",
" expand 1 = AlgHom.id R (MvPolynomial Ο R)",
" (expand 1) (X f) = (AlgHom.id R (MvPolynomial Ο R)) (X f)",
" (expand p).comp (bindβ f) = bindβ fun i => (expand p) (f i)",
" β (i : Ο), ((expand p).comp (bindβ f)) (X i) = (bindβ fun i => (expand p) (f i)) (X i)",
" ((expand p).comp (bi... | [
" (expand 1) f = f",
" expand 1 = AlgHom.id R (MvPolynomial Ο R)",
" (expand 1) (X f) = (AlgHom.id R (MvPolynomial Ο R)) (X f)",
" (expand p).comp (bindβ f) = bindβ fun i => (expand p) (f i)",
" β (i : Ο), ((expand p).comp (bindβ f)) (X i) = (bindβ fun i => (expand p) (f i)) (X i)",
" ((expand p).comp (bi... |
import Mathlib.Analysis.NormedSpace.PiLp
import Mathlib.Analysis.InnerProductSpace.PiL2
#align_import analysis.matrix from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open scoped NNReal Matrix
namespace Matrix
variable {R l m n Ξ± Ξ² : Type*} [Fintype l] [Fintyp... | Mathlib/Analysis/Matrix.lean | 102 | 104 | theorem nnnorm_lt_iff {r : ββ₯0} (hr : 0 < r) {A : Matrix m n Ξ±} :
βAββ < r β β i j, βA i jββ < r := by |
simp_rw [nnnorm_def, pi_nnnorm_lt_iff hr]
| [
" βAβ = β(Finset.univ.sup fun i => Finset.univ.sup fun j => βA i jββ)",
" βAβ β€ r β β (i : m) (j : n), βA i jβ β€ r",
" βAββ β€ r β β (i : m) (j : n), βA i jββ β€ r",
" βAβ < r β β (i : m) (j : n), βA i jβ < r",
" βAββ < r β β (i : m) (j : n), βA i jββ < r"
] | [
" βAβ = β(Finset.univ.sup fun i => Finset.univ.sup fun j => βA i jββ)",
" βAβ β€ r β β (i : m) (j : n), βA i jβ β€ r",
" βAββ β€ r β β (i : m) (j : n), βA i jββ β€ r",
" βAβ < r β β (i : m) (j : n), βA i jβ < r"
] |
import Mathlib.Algebra.Group.Subsemigroup.Basic
#align_import group_theory.subsemigroup.membership from "leanprover-community/mathlib"@"6cb77a8eaff0ddd100e87b1591c6d3ad319514ff"
assert_not_exists MonoidWithZero
variable {ΞΉ : Sort*} {M A B : Type*}
section NonAssoc
variable [Mul M]
open Set
namespace Subsemigr... | Mathlib/Algebra/Group/Subsemigroup/Membership.lean | 67 | 70 | theorem mem_sSup_of_directed_on {S : Set (Subsemigroup M)} (hS : DirectedOn (Β· β€ Β·) S) {x : M} :
x β sSup S β β s β S, x β s := by |
simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk,
exists_prop]
| [
" x β β¨ i, S i β β i, x β S i",
" x β β¨ i, S i β β i, x β S i",
" x β closure (β i, β(S i)) β β i, x β S i",
" β (x y : M), (β i, x β S i) β (β i, y β S i) β β i, x * y β S i",
" β i, x * y β S i",
" x β β(β¨ i, S i) β x β β i, β(S i)",
" x β sSup S β β s β S, x β s"
] | [
" x β β¨ i, S i β β i, x β S i",
" x β β¨ i, S i β β i, x β S i",
" x β closure (β i, β(S i)) β β i, x β S i",
" β (x y : M), (β i, x β S i) β (β i, y β S i) β β i, x * y β S i",
" β i, x * y β S i",
" x β β(β¨ i, S i) β x β β i, β(S i)"
] |
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.supported from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
universe u v w
namespace MvPolynomial
variable {Ο Ο : Type*} {R : Type u} {S : Type v} {r : R} {e : β} {n m : Ο}
section CommSemiring
variable... | Mathlib/Algebra/MvPolynomial/Supported.lean | 117 | 118 | theorem X_mem_supported [Nontrivial R] {i : Ο} : X i β supported R s β i β s := by |
simp [mem_supported]
| [
" supported R s = (rename Subtype.val).range",
" (aeval fun x => X βx).range = (aeval (X β Subtype.val)).range",
" (supportedEquivMvPolynomial s).symm (C x) = (algebraMap R β₯(supported R s)) x",
" β((supportedEquivMvPolynomial s).symm (C x)) = β((algebraMap R β₯(supported R s)) x)",
" β((supportedEquivMvPoly... | [
" supported R s = (rename Subtype.val).range",
" (aeval fun x => X βx).range = (aeval (X β Subtype.val)).range",
" (supportedEquivMvPolynomial s).symm (C x) = (algebraMap R β₯(supported R s)) x",
" β((supportedEquivMvPolynomial s).symm (C x)) = β((algebraMap R β₯(supported R s)) x)",
" β((supportedEquivMvPoly... |
import Mathlib.Analysis.Calculus.Deriv.Add
import Mathlib.Analysis.Calculus.Deriv.Mul
import Mathlib.Analysis.Calculus.LocalExtr.Basic
#align_import analysis.calculus.darboux from "leanprover-community/mathlib"@"61b5e2755ccb464b68d05a9acf891ae04992d09d"
open Filter Set
open scoped Topology Classical
variable {a ... | Mathlib/Analysis/Calculus/Darboux.lean | 76 | 90 | theorem Set.OrdConnected.image_hasDerivWithinAt {s : Set β} (hs : OrdConnected s)
(hf : β x β s, HasDerivWithinAt f (f' x) s x) : OrdConnected (f' '' s) := by |
apply ordConnected_of_Ioo
rintro _ β¨a, ha, rflβ© _ β¨b, hb, rflβ© - m β¨hma, hmbβ©
rcases le_total a b with hab | hab
Β· have : Icc a b β s := hs.out ha hb
rcases exists_hasDerivWithinAt_eq_of_gt_of_lt hab (fun x hx => (hf x <| this hx).mono this) hma
hmb with
β¨c, cmem, hcβ©
exact β¨c, this <| Io... | [
" m β f' '' Ioo a b",
" m β f' '' Ioo a a",
" β x β Icc a b, HasDerivWithinAt g (f' x - m) (Icc a b) x",
" HasDerivWithinAt g (f' x - m) (Icc a b) x",
" c β Ioo a b",
" a β Ioo a b",
" 0 β€ (b - a) * (f' a - m)",
" b β Ioo a b",
" 0 β€ (a - b) * (f' b - m)",
" segment β b a β Icc a b",
" f' c = m"... | [
" m β f' '' Ioo a b",
" m β f' '' Ioo a a",
" β x β Icc a b, HasDerivWithinAt g (f' x - m) (Icc a b) x",
" HasDerivWithinAt g (f' x - m) (Icc a b) x",
" c β Ioo a b",
" a β Ioo a b",
" 0 β€ (b - a) * (f' a - m)",
" b β Ioo a b",
" 0 β€ (a - b) * (f' b - m)",
" segment β b a β Icc a b",
" f' c = m"... |
import Mathlib.LinearAlgebra.Matrix.BilinearForm
import Mathlib.LinearAlgebra.Matrix.Charpoly.Minpoly
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.Vandermonde
import Mathlib.LinearAlgebra.Trace
import Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosu... | Mathlib/RingTheory/Trace.lean | 109 | 111 | theorem trace_eq_matrix_trace [DecidableEq ΞΉ] (b : Basis ΞΉ R S) (s : S) :
trace R S s = Matrix.trace (Algebra.leftMulMatrix b s) := by |
rw [trace_apply, LinearMap.trace_eq_matrix_trace _ b, β toMatrix_lmul_eq]; rfl
| [
" trace R S = 0",
" (trace R S) s = 0 s",
" (trace R S) s = ((leftMulMatrix b) s).trace",
" ((toMatrix b b) ((lmul R S) s)).trace = ((toMatrix b b) (mulLeft R s)).trace"
] | [
" trace R S = 0",
" (trace R S) s = 0 s"
] |
import Mathlib.Algebra.CharP.LocalRing
import Mathlib.RingTheory.Ideal.Quotient
import Mathlib.Tactic.FieldSimp
#align_import algebra.char_p.mixed_char_zero from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
variable (R : Type*) [CommRing R]
class MixedCharZero (p : β) : Prop where
... | Mathlib/Algebra/CharP/MixedCharZero.lean | 85 | 105 | theorem reduce_to_p_prime {P : Prop} :
(β p > 0, MixedCharZero R p β P) β β p : β, p.Prime β MixedCharZero R p β P := by |
constructor
Β· intro h q q_prime q_mixedChar
exact h q (Nat.Prime.pos q_prime) q_mixedChar
Β· intro h q q_pos q_mixedChar
rcases q_mixedChar.charP_quotient with β¨I, hI_ne_top, _β©
-- Krull's Thm: There exists a prime ideal `P` such that `I β€ P`
rcases Ideal.exists_le_maximal I hI_ne_top with β¨M, hM_... | [
" (β p > 0, MixedCharZero R p β P) β β (p : β), p.Prime β MixedCharZero R p β P",
" (β p > 0, MixedCharZero R p β P) β β (p : β), p.Prime β MixedCharZero R p β P",
" P",
" (β (p : β), p.Prime β MixedCharZero R p β P) β β p > 0, MixedCharZero R p β P",
" r β 0",
" r β£ q",
" MixedCharZero R r"
] | [] |
import Mathlib.Geometry.Manifold.Algebra.Monoid
#align_import geometry.manifold.algebra.lie_group from "leanprover-community/mathlib"@"f9ec187127cc5b381dfcf5f4a22dacca4c20b63d"
noncomputable section
open scoped Manifold
-- See note [Design choices about smooth algebraic structures]
class LieAddGroup {π : Type*... | Mathlib/Geometry/Manifold/Algebra/LieGroup.lean | 171 | 174 | theorem ContMDiffWithinAt.div {f g : M β G} {s : Set M} {xβ : M}
(hf : ContMDiffWithinAt I' I n f s xβ) (hg : ContMDiffWithinAt I' I n g s xβ) :
ContMDiffWithinAt I' I n (fun x => f x / g x) s xβ := by |
simp_rw [div_eq_mul_inv]; exact hf.mul hg.inv
| [
" ContMDiffWithinAt I' I n (fun x => f x / g x) s xβ",
" ContMDiffWithinAt I' I n (fun x => f x * (g x)β»ΒΉ) s xβ"
] | [] |
import Batteries.Data.DList
import Mathlib.Mathport.Rename
import Mathlib.Tactic.Cases
#align_import data.dlist from "leanprover-community/lean"@"855e5b74e3a52a40552e8f067169d747d48743fd"
universe u
#align dlist Batteries.DList
namespace Batteries.DList
open Function
variable {Ξ± : Type u}
#align dlist.of_list... | Mathlib/Data/DList/Defs.lean | 80 | 81 | theorem toList_cons (x : Ξ±) (l : DList Ξ±) : toList (cons x l) = x :: toList l := by |
cases l; simp
| [
" (fun xs => l.get ++ xs) t = (fun xs => l.get ++ xs) [] ++ t",
" (ofList l).toList = l",
" (ofList (headβ :: tailβ)).toList = headβ :: tailβ",
" ofList l.toList = l",
" ofList { apply := app, invariant := inv }.toList = { apply := app, invariant := inv }",
" (fun x => app [] ++ x) = app",
" app [] ++ x... | [
" (fun xs => l.get ++ xs) t = (fun xs => l.get ++ xs) [] ++ t",
" (ofList l).toList = l",
" (ofList (headβ :: tailβ)).toList = headβ :: tailβ",
" ofList l.toList = l",
" ofList { apply := app, invariant := inv }.toList = { apply := app, invariant := inv }",
" (fun x => app [] ++ x) = app",
" app [] ++ x... |
import Mathlib.Algebra.MvPolynomial.Funext
import Mathlib.Algebra.Ring.ULift
import Mathlib.RingTheory.WittVector.Basic
#align_import ring_theory.witt_vector.is_poly from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
namespace WittVector
universe u
variable {p : β} {R S : Type u} {Ο id... | Mathlib/RingTheory/WittVector/IsPoly.lean | 125 | 133 | theorem poly_eq_of_wittPolynomial_bind_eq [Fact p.Prime] (f g : β β MvPolynomial β β€)
(h : β n, bindβ f (wittPolynomial p _ n) = bindβ g (wittPolynomial p _ n)) : f = g := by |
ext1 n
apply MvPolynomial.map_injective (Int.castRingHom β) Int.cast_injective
rw [β Function.funext_iff] at h
replace h :=
congr_arg (fun fam => bindβ (MvPolynomial.map (Int.castRingHom β) β fam) (xInTermsOfW p β n)) h
simpa only [Function.comp, map_bindβ, map_wittPolynomial, β bindβ_bindβ,
bindβ_wi... | [
" f = g",
" f n = g n",
" (MvPolynomial.map (Int.castRingHom β)) (f n) = (MvPolynomial.map (Int.castRingHom β)) (g n)"
] | [
" f = g",
" f n = g n",
" (MvPolynomial.map (Int.castRingHom β)) (f n) = (MvPolynomial.map (Int.castRingHom β)) (g n)"
] |
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
#align_i... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | 132 | 134 | theorem isHomogeneous_C (r : R) : IsHomogeneous (C r : MvPolynomial Ο R) 0 := by |
apply isHomogeneous_monomial
simp only [degree, Finsupp.zero_apply, Finset.sum_const_zero]
| [
" (weightedDegree 1) d = degree d",
" weightedTotalDegree 1 Ο = Ο.totalDegree",
" (weightedDegree 1) c = n",
" coeff c a β 0 β¨ coeff c b β 0",
" coeff c a + coeff c b = 0",
" coeff c a β 0",
" False",
" r β’ coeff c a = 0",
" r β’ 0 = 0",
" homogeneousSubmodule Ο R n = Finsupp.supported R R {d | deg... | [
" (weightedDegree 1) d = degree d",
" weightedTotalDegree 1 Ο = Ο.totalDegree",
" (weightedDegree 1) c = n",
" coeff c a β 0 β¨ coeff c b β 0",
" coeff c a + coeff c b = 0",
" coeff c a β 0",
" False",
" r β’ coeff c a = 0",
" r β’ 0 = 0",
" homogeneousSubmodule Ο R n = Finsupp.supported R R {d | deg... |
import Mathlib.Algebra.Polynomial.Expand
import Mathlib.Algebra.Polynomial.Laurent
import Mathlib.LinearAlgebra.Matrix.Charpoly.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.RingTheory.Polynomial.Nilpotent
#align_import linear_algebra.matrix.charpoly.coeff from "leanprover-community/mathlib"@"9745b... | Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean | 96 | 119 | theorem charpoly_degree_eq_dim [Nontrivial R] (M : Matrix n n R) :
M.charpoly.degree = Fintype.card n := by |
by_cases h : Fintype.card n = 0
Β· rw [h]
unfold charpoly
rw [det_of_card_zero]
Β· simp
Β· assumption
rw [β sub_add_cancel M.charpoly (β i : n, (X - C (M i i)))]
-- Porting note: added `β` in front of `Fintype.card n`
have h1 : (β i : n, (X - C (M i i))).degree = β(Fintype.card n) := by
rw [... | [
" (M.charmatrix i j).natDegree = if i = j then 1 else 0",
" (M.charmatrix i j).natDegree β€ if i = j then 1 else 0",
" (M.charmatrix i j).natDegree β€ 1",
" (M.charmatrix i j).natDegree β€ 0",
" (M.charpoly - β i : n, (X - C (M i i))).degree < β(Fintype.card n - 1)",
" (β x β univ.erase (Equiv.refl n), ββ(Eq... | [
" (M.charmatrix i j).natDegree = if i = j then 1 else 0",
" (M.charmatrix i j).natDegree β€ if i = j then 1 else 0",
" (M.charmatrix i j).natDegree β€ 1",
" (M.charmatrix i j).natDegree β€ 0",
" (M.charpoly - β i : n, (X - C (M i i))).degree < β(Fintype.card n - 1)",
" (β x β univ.erase (Equiv.refl n), ββ(Eq... |
import Mathlib.Algebra.MvPolynomial.Counit
import Mathlib.Algebra.MvPolynomial.Invertible
import Mathlib.RingTheory.WittVector.Defs
#align_import ring_theory.witt_vector.basic from "leanprover-community/mathlib"@"9556784a5b84697562e9c6acb40500d4a82e675a"
noncomputable section
open MvPolynomial Function
variable... | Mathlib/RingTheory/WittVector/Basic.lean | 120 | 120 | theorem nsmul (n : β) (x : WittVector p R) : mapFun f (n β’ x) = n β’ mapFun f x := by | map_fun_tac
| [
" Injective (mapFun f)",
" aββ = aββ",
" aββ.coeff p = aββ.coeff p",
" mapFun f (mk p fun n => Classical.choose β―) = x",
" (mapFun f (mk p fun n => Classical.choose β―)).coeff n = x.coeff n",
" mapFun (βf) 0 = 0",
" mapFun (βf) 1 = 1",
" mapFun (βf) (x + y) = mapFun (βf) x + mapFun (βf) y",
" mapFun ... | [
" Injective (mapFun f)",
" aββ = aββ",
" aββ.coeff p = aββ.coeff p",
" mapFun f (mk p fun n => Classical.choose β―) = x",
" (mapFun f (mk p fun n => Classical.choose β―)).coeff n = x.coeff n",
" mapFun (βf) 0 = 0",
" mapFun (βf) 1 = 1",
" mapFun (βf) (x + y) = mapFun (βf) x + mapFun (βf) y",
" mapFun ... |
import Mathlib.Data.Real.Irrational
import Mathlib.Data.Nat.Fib.Basic
import Mathlib.Data.Fin.VecNotation
import Mathlib.Algebra.LinearRecurrence
import Mathlib.Tactic.NormNum.NatFib
import Mathlib.Tactic.NormNum.Prime
#align_import data.real.golden_ratio from "leanprover-community/mathlib"@"2196ab363eb097c008d449712... | Mathlib/Data/Real/GoldenRatio.lean | 79 | 80 | theorem one_sub_gold : 1 - Ο = Ο := by |
linarith [gold_add_goldConj]
| [
" Οβ»ΒΉ = -Ο",
" 0 < 1",
" 0 < 5",
" 2 * 2 = 5 - 1",
" Οβ»ΒΉ = -Ο",
" -Ο = Οβ»ΒΉ",
" Ο * Ο = -1",
" (1 + β5) * (1 - β5) = -(2 * 2)",
" 1 ^ 2 - β5 ^ 2 = -(2 * 2)",
" Ο * Ο = -1",
" Ο + Ο = 1",
" (1 + β5) / 2 + (1 - β5) / 2 = 1",
" 1 - Ο = Ο",
" 1 - Ο = Ο"
] | [
" Οβ»ΒΉ = -Ο",
" 0 < 1",
" 0 < 5",
" 2 * 2 = 5 - 1",
" Οβ»ΒΉ = -Ο",
" -Ο = Οβ»ΒΉ",
" Ο * Ο = -1",
" (1 + β5) * (1 - β5) = -(2 * 2)",
" 1 ^ 2 - β5 ^ 2 = -(2 * 2)",
" Ο * Ο = -1",
" Ο + Ο = 1",
" (1 + β5) / 2 + (1 - β5) / 2 = 1",
" 1 - Ο = Ο"
] |
import Mathlib.Data.Nat.Count
import Mathlib.Data.Nat.SuccPred
import Mathlib.Order.Interval.Set.Monotone
import Mathlib.Order.OrderIsoNat
#align_import data.nat.nth from "leanprover-community/mathlib"@"7fdd4f3746cb059edfdb5d52cba98f66fce418c0"
open Finset
namespace Nat
variable (p : β β Prop)
noncomputable d... | Mathlib/Data/Nat/Nth.lean | 137 | 138 | theorem nth_apply_eq_orderIsoOfNat (hf : (setOf p).Infinite) (n : β) :
nth p n = @Nat.Subtype.orderIsoOfNat (setOf p) hf.to_subtype n := by | rw [nth, dif_neg hf]
| [
" β",
" nth p n = 0",
" (sort (fun x x_1 => x β€ x_1) hf.toFinset).length β€ n",
" nth p n = (hf.toFinset.orderEmbOfFin β―) β¨n, hnβ©",
" StrictMonoOn (nth p) (Set.Iio hf.toFinset.card)",
" nth p m < nth p n",
" (β―.toFinset.orderEmbOfFin β―) β¨m, β―β© < (β―.toFinset.orderEmbOfFin β―) β¨n, β―β©",
" Set.range (nth p)... | [
" β",
" nth p n = 0",
" (sort (fun x x_1 => x β€ x_1) hf.toFinset).length β€ n",
" nth p n = (hf.toFinset.orderEmbOfFin β―) β¨n, hnβ©",
" StrictMonoOn (nth p) (Set.Iio hf.toFinset.card)",
" nth p m < nth p n",
" (β―.toFinset.orderEmbOfFin β―) β¨m, β―β© < (β―.toFinset.orderEmbOfFin β―) β¨n, β―β©",
" Set.range (nth p)... |
import Mathlib.Analysis.Calculus.ContDiff.RCLike
import Mathlib.MeasureTheory.Measure.Hausdorff
#align_import topology.metric_space.hausdorff_dimension from "leanprover-community/mathlib"@"8f9fea08977f7e450770933ee6abb20733b47c92"
open scoped MeasureTheory ENNReal NNReal Topology
open MeasureTheory MeasureTheory... | Mathlib/Topology/MetricSpace/HausdorffDimension.lean | 139 | 144 | theorem hausdorffMeasure_of_dimH_lt {s : Set X} {d : ββ₯0} (h : dimH s < d) : ΞΌH[d] s = 0 := by |
rw [dimH_def] at h
rcases ENNReal.lt_iff_exists_nnreal_btwn.1 h with β¨d', hsd', hd'dβ©
rw [ENNReal.coe_lt_coe, β NNReal.coe_lt_coe] at hd'd
exact (hausdorffMeasure_zero_or_top hd'd s).resolve_right fun hβ => hsd'.not_le <|
le_iSupβ (Ξ± := ββ₯0β) d' hβ
| [
" ββ₯0β",
" dimH s = β¨ d, β¨ (_ : ΞΌH[βd] s = β€), βd",
" ΞΌH[βd] s = β€",
" βd β€ dimH s",
" βd β€ β¨ d, β¨ (_ : ΞΌH[βd] s = β€), βd",
" ΞΌH[βd] s = 0"
] | [
" ββ₯0β",
" dimH s = β¨ d, β¨ (_ : ΞΌH[βd] s = β€), βd",
" ΞΌH[βd] s = β€",
" βd β€ dimH s",
" βd β€ β¨ d, β¨ (_ : ΞΌH[βd] s = β€), βd"
] |
import Mathlib.Algebra.Polynomial.DenomsClearable
import Mathlib.Analysis.Calculus.MeanValue
import Mathlib.Analysis.Calculus.Deriv.Polynomial
import Mathlib.Data.Real.Irrational
import Mathlib.Topology.Algebra.Polynomial
#align_import number_theory.liouville.basic from "leanprover-community/mathlib"@"04e80bb7e851095... | Mathlib/NumberTheory/Liouville/Basic.lean | 123 | 173 | theorem exists_pos_real_of_irrational_root {Ξ± : β} (ha : Irrational Ξ±) {f : β€[X]} (f0 : f β 0)
(fa : eval Ξ± (map (algebraMap β€ β) f) = 0) :
β A : β, 0 < A β§ β a : β€, β b : β,
(1 : β) β€ ((b : β) + 1) ^ f.natDegree * (|Ξ± - a / (b + 1)| * A) := by |
-- `fR` is `f` viewed as a polynomial with `β` coefficients.
set fR : β[X] := map (algebraMap β€ β) f
-- `fR` is non-zero, since `f` is non-zero.
obtain fR0 : fR β 0 := fun fR0 =>
(map_injective (algebraMap β€ β) fun _ _ A => Int.cast_inj.mp A).ne f0
(fR0.trans (Polynomial.map_zero _).symm)
-- reform... | [
" Irrational x",
" False",
" |a * q - βb * p| * q ^ (b + 1) < βb * q",
" a * q - βb * p β 0",
" β A, 0 < A β§ β (z : Z) (a : N), 1 β€ d a * (dist Ξ± (j z a) * A)",
" 1 β€ d a * (dist Ξ± (j z a) * max (1 / Ξ΅) M)",
" j z a β closedBall Ξ± Ξ΅",
" dist Ξ± (j z a) β€ 1 / max (1 / Ξ΅) M",
" d a * dist (f Ξ±) (f (j z... | [
" Irrational x",
" False",
" |a * q - βb * p| * q ^ (b + 1) < βb * q",
" a * q - βb * p β 0",
" β A, 0 < A β§ β (z : Z) (a : N), 1 β€ d a * (dist Ξ± (j z a) * A)",
" 1 β€ d a * (dist Ξ± (j z a) * max (1 / Ξ΅) M)",
" j z a β closedBall Ξ± Ξ΅",
" dist Ξ± (j z a) β€ 1 / max (1 / Ξ΅) M",
" d a * dist (f Ξ±) (f (j z... |
import Mathlib.Algebra.Order.Ring.Abs
#align_import data.int.order.units from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
namespace Int
theorem isUnit_iff_abs_eq {x : β€} : IsUnit x β abs x = 1 := by
rw [isUnit_iff_natAbs_eq, abs_eq_natAbs, β Int.ofNat_one, natCast_inj]
#align int.... | Mathlib/Data/Int/Order/Units.lean | 49 | 49 | theorem neg_one_pow_ne_zero {n : β} : (-1 : β€) ^ n β 0 := by | simp
| [
" IsUnit x β |x| = 1",
" a ^ 2 = 1",
" u ^ 2 = 1",
" u * u = 1",
" uβ»ΒΉ = u",
" uβ / uβ = uβ * uβ",
" βu * βu = 1",
" (-1) ^ n β 0"
] | [
" IsUnit x β |x| = 1",
" a ^ 2 = 1",
" u ^ 2 = 1",
" u * u = 1",
" uβ»ΒΉ = u",
" uβ / uβ = uβ * uβ",
" βu * βu = 1"
] |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Normed.Field.InfiniteSum
import Mathlib.Data.Nat.Choose.Cast
import Mathlib.Data.Finset.NoncommProd
import Mathlib.Topology.Algebra.Algebra
#align_import analysis.normed_space.exponential from "leanprover-community/ma... | Mathlib/Analysis/NormedSpace/Exponential.lean | 172 | 175 | theorem _root_.Commute.exp_right [T2Space πΈ] {x y : πΈ} (h : Commute x y) :
Commute x (exp π y) := by |
rw [exp_eq_tsum]
exact Commute.tsum_right x fun n => (h.pow_right n).smul_right _
| [
" ((expSeries π πΈ n) fun x_1 => x) = (βn !)β»ΒΉ β’ x ^ n",
" ((expSeries π πΈ n) fun x => 0) = Pi.single 0 1 n",
" (βn !)β»ΒΉ β’ 0 ^ n = Pi.single 0 1 n",
" (β0!)β»ΒΉ β’ 0 ^ 0 = Pi.single 0 1 0",
" (β(n + 1)!)β»ΒΉ β’ 0 ^ (n + 1) = Pi.single 0 1 (n + 1)",
" exp π 0 = 1",
" exp π (MulOpposite.op x) = MulOpposite... | [
" ((expSeries π πΈ n) fun x_1 => x) = (βn !)β»ΒΉ β’ x ^ n",
" ((expSeries π πΈ n) fun x => 0) = Pi.single 0 1 n",
" (βn !)β»ΒΉ β’ 0 ^ n = Pi.single 0 1 n",
" (β0!)β»ΒΉ β’ 0 ^ 0 = Pi.single 0 1 0",
" (β(n + 1)!)β»ΒΉ β’ 0 ^ (n + 1) = Pi.single 0 1 (n + 1)",
" exp π 0 = 1",
" exp π (MulOpposite.op x) = MulOpposite... |
import Mathlib.Algebra.CharP.ExpChar
import Mathlib.GroupTheory.OrderOfElement
#align_import algebra.char_p.two from "leanprover-community/mathlib"@"7f1ba1a333d66eed531ecb4092493cd1b6715450"
variable {R ΞΉ : Type*}
namespace CharTwo
section Semiring
variable [Semiring R] [CharP R 2]
theorem two_eq_zero : (2 : ... | Mathlib/Algebra/CharP/Two.lean | 33 | 33 | theorem add_self_eq_zero (x : R) : x + x = 0 := by | rw [β two_smul R x, two_eq_zero, zero_smul]
| [
" 2 = 0",
" x + x = 0"
] | [
" 2 = 0"
] |
import Mathlib.LinearAlgebra.Dual
open Function Module
variable (R M N : Type*) [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N]
structure PerfectPairing :=
toLin : M ββ[R] N ββ[R] R
bijectiveLeft : Bijective toLin
bijectiveRight : Bijective toLin.flip
attribute [nolint docBlame] P... | Mathlib/LinearAlgebra/PerfectPairing.lean | 71 | 74 | theorem apply_toDualLeft_symm_apply (f : Dual R N) (x : N) : p (p.toDualLeft.symm f) x = f x := by |
have h := LinearEquiv.apply_symm_apply p.toDualLeft f
rw [toDualLeft_apply] at h
exact congrFun (congrArg DFunLike.coe h) x
| [
" x = y",
" { toLin := toLinβ, bijectiveLeft := bijectiveLeftβ, bijectiveRight := bijectiveRightβ } = y",
" { toLin := toLinβΒΉ, bijectiveLeft := bijectiveLeftβΒΉ, bijectiveRight := bijectiveRightβΒΉ } =\n { toLin := toLinβ, bijectiveLeft := bijectiveLeftβ, bijectiveRight := bijectiveRightβ }",
" (p (p.toDual... | [
" x = y",
" { toLin := toLinβ, bijectiveLeft := bijectiveLeftβ, bijectiveRight := bijectiveRightβ } = y",
" { toLin := toLinβΒΉ, bijectiveLeft := bijectiveLeftβΒΉ, bijectiveRight := bijectiveRightβΒΉ } =\n { toLin := toLinβ, bijectiveLeft := bijectiveLeftβ, bijectiveRight := bijectiveRightβ }"
] |
import Mathlib.Topology.UniformSpace.CompactConvergence
import Mathlib.Topology.UniformSpace.Equicontinuity
import Mathlib.Topology.UniformSpace.Equiv
open Set Filter Uniformity Topology Function UniformConvergence
variable {ΞΉ X Y Ξ± Ξ² : Type*} [TopologicalSpace X] [UniformSpace Ξ±] [UniformSpace Ξ²]
variable {F : ΞΉ ... | Mathlib/Topology/UniformSpace/Ascoli.lean | 85 | 125 | theorem Equicontinuous.comap_uniformFun_eq [CompactSpace X] (F_eqcont : Equicontinuous F) :
(UniformFun.uniformSpace X Ξ±).comap F =
(Pi.uniformSpace _).comap F := by |
-- The `β€` inequality is trivial
refine le_antisymm (UniformSpace.comap_mono UniformFun.uniformContinuous_toFun) ?_
-- A bit of rewriting to get a nice intermediate statement.
change comap _ _ β€ comap _ _
simp_rw [Pi.uniformity, Filter.comap_iInf, comap_comap, Function.comp]
refine ((UniformFun.hasBasis_un... | [
" UniformSpace.comap F (UniformFun.uniformSpace X Ξ±) = UniformSpace.comap F (Pi.uniformSpace fun i => Ξ±)",
" UniformSpace.comap F (Pi.uniformSpace fun i => Ξ±) β€ UniformSpace.comap F (UniformFun.uniformSpace X Ξ±)",
" comap (fun p => (F p.1, F p.2)) (π€ (X β Ξ±)) β€ comap (fun p => (F p.1, F p.2)) (π€ (X β Ξ±))",
... | [] |
import Mathlib.Algebra.Polynomial.Mirror
import Mathlib.Analysis.Complex.Polynomial
#align_import data.polynomial.unit_trinomial from "leanprover-community/mathlib"@"302eab4f46abb63de520828de78c04cb0f9b5836"
namespace Polynomial
open scoped Polynomial
open Finset
section Semiring
variable {R : Type*} [Semirin... | Mathlib/Algebra/Polynomial/UnitTrinomial.lean | 67 | 78 | theorem trinomial_natDegree (hkm : k < m) (hmn : m < n) (hw : w β 0) :
(trinomial k m n u v w).natDegree = n := by |
refine
natDegree_eq_of_degree_eq_some
((Finset.sup_le fun i h => ?_).antisymm <|
le_degree_of_ne_zero <| by rwa [trinomial_leading_coeff' hkm hmn])
replace h := support_trinomial' k m n u v w h
rw [mem_insert, mem_insert, mem_singleton] at h
rcases h with (rfl | rfl | rfl)
Β· exact WithBot.c... | [
" (trinomial k m n u v w).coeff n = w",
" (trinomial k m n u v w).coeff m = v",
" (trinomial k m n u v w).coeff k = u",
" (trinomial k m n u v w).natDegree = n",
" (trinomial k m n u v w).coeff n β 0",
" βi β€ βn",
" βi β€ βi"
] | [
" (trinomial k m n u v w).coeff n = w",
" (trinomial k m n u v w).coeff m = v",
" (trinomial k m n u v w).coeff k = u"
] |
import Mathlib.Order.BooleanAlgebra
import Mathlib.Logic.Equiv.Basic
#align_import order.symm_diff from "leanprover-community/mathlib"@"6eb334bd8f3433d5b08ba156b8ec3e6af47e1904"
open Function OrderDual
variable {ΞΉ Ξ± Ξ² : Type*} {Ο : ΞΉ β Type*}
def symmDiff [Sup Ξ±] [SDiff Ξ±] (a b : Ξ±) : Ξ± :=
a \ b β b \ a
#ali... | Mathlib/Order/SymmDiff.lean | 96 | 96 | theorem Bool.symmDiff_eq_xor : β p q : Bool, p β q = xor p q := by | decide
| [
" β (p q : Bool), p β q = xor p q"
] | [] |
import Mathlib.Topology.Homeomorph
import Mathlib.Topology.Order.LeftRightNhds
#align_import topology.algebra.order.monotone_continuity from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Set Filter
open Topology
section LinearOrder
variable {Ξ± Ξ² : Type*} [LinearOrder Ξ±] [Topolo... | Mathlib/Topology/Order/MonotoneContinuity.lean | 63 | 75 | theorem continuousWithinAt_right_of_monotoneOn_of_exists_between {f : Ξ± β Ξ²} {s : Set Ξ±} {a : Ξ±}
(h_mono : MonotoneOn f s) (hs : s β π[β₯] a) (hfs : β b > f a, β c β s, f c β Ioo (f a) b) :
ContinuousWithinAt f (Ici a) a := by |
have ha : a β Ici a := left_mem_Ici
have has : a β s := mem_of_mem_nhdsWithin ha hs
refine tendsto_order.2 β¨fun b hb => ?_, fun b hb => ?_β©
Β· filter_upwards [hs, @self_mem_nhdsWithin _ _ a (Ici a)] with _ hxs hxa using hb.trans_le
(h_mono has hxs hxa)
Β· rcases hfs b hb with β¨c, hcs, hac, hcbβ©
have ... | [
" ContinuousWithinAt f (Ici a) a",
" βαΆ (b_1 : Ξ±) in π[β₯] a, b < f b_1",
" βαΆ (b_1 : Ξ±) in π[β₯] a, f b_1 < b",
" β a_1 β s, a_1 β Ico a c β f a_1 < b",
" f x < b"
] | [
" ContinuousWithinAt f (Ici a) a",
" βαΆ (b_1 : Ξ±) in π[β₯] a, b < f b_1",
" βαΆ (b_1 : Ξ±) in π[β₯] a, f b_1 < b",
" β a_1 β s, a_1 β Ico a c β f a_1 < b",
" f x < b"
] |
import Batteries.Data.List.Basic
import Batteries.Data.List.Lemmas
open Nat
namespace List
section countP
variable (p q : Ξ± β Bool)
@[simp] theorem countP_nil : countP p [] = 0 := rfl
protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 := by
induction l generalizing n with
| nil... | .lake/packages/batteries/Batteries/Data/List/Count.lean | 81 | 82 | theorem countP_eq_length : countP p l = l.length β β a β l, p a := by |
rw [countP_eq_length_filter, filter_length_eq_length]
| [
" countP.go p l n = n + countP.go p l 0",
" countP.go p [] n = n + countP.go p [] 0",
" countP.go p (head :: tail) n = n + countP.go p (head :: tail) 0",
" (bif p head then countP.go p tail (n + 1) else countP.go p tail n) =\n n + bif p head then countP.go p tail (0 + 1) else countP.go p tail 0",
" (bif ... | [
" countP.go p l n = n + countP.go p l 0",
" countP.go p [] n = n + countP.go p [] 0",
" countP.go p (head :: tail) n = n + countP.go p (head :: tail) 0",
" (bif p head then countP.go p tail (n + 1) else countP.go p tail n) =\n n + bif p head then countP.go p tail (0 + 1) else countP.go p tail 0",
" (bif ... |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Constructions.Prod.Integral
import Mathlib.MeasureTheory.Function.LocallyIntegrable
import Mathlib.MeasureTheory.Group.Integral
import Mathlib.MeasureTheory.Group.Prod
import Mathlib.Measure... | Mathlib/Analysis/Convolution.lean | 118 | 128 | theorem convolution_integrand_bound_right_of_le_of_subset {C : β} (hC : β i, βg iβ β€ C) {x t : G}
{s u : Set G} (hx : x β s) (hu : -tsupport g + s β u) :
βL (f t) (g (x - t))β β€ u.indicator (fun t => βLβ * βf tβ * C) t := by |
-- Porting note: had to add `f := _`
refine le_indicator (f := fun t β¦ βL (f t) (g (x - t))β) (fun t _ => ?_) (fun t ht => ?_) t
Β· apply_rules [L.le_of_opNormβ_le_of_le, le_rfl]
Β· have : x - t β support g := by
refine mt (fun hxt => hu ?_) ht
refine β¨_, Set.neg_mem_neg.mpr (subset_closure hxt), _, ... | [
" β(L (f t)) (g (x - t))β β€ u.indicator (fun t => βLβ * βf tβ * C) t",
" (fun t => β(L (f t)) (g (x - t))β) t β€ βLβ * βf tβ * C",
" (fun t => β(L (f t)) (g (x - t))β) t β€ 0",
" x - t β support g",
" t β -tsupport g + s",
" (fun x x_1 => x + x_1) (-(x - t)) x = t"
] | [] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.Algebra.Polynomial.HasseDeriv
#align_import data.polynomial.taylor from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
namespace Polynomial
open Polynomial... | Mathlib/Algebra/Polynomial/Taylor.lean | 93 | 94 | theorem taylor_coeff_one : (taylor r f).coeff 1 = f.derivative.eval r := by |
rw [taylor_coeff, hasseDeriv_one]
| [
" { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun (c β’ f) =\n (RingHom.id R) c β’ { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun f",
" (taylor r) X = X + C r",
" (taylor r) (C x) = C x",
" taylor 0 = LinearMap.id",
" ((taylor 0 ββ monomial nβΒΉ) 1).coeff nβ = ((LinearMap.id ββ mono... | [
" { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun (c β’ f) =\n (RingHom.id R) c β’ { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun f",
" (taylor r) X = X + C r",
" (taylor r) (C x) = C x",
" taylor 0 = LinearMap.id",
" ((taylor 0 ββ monomial nβΒΉ) 1).coeff nβ = ((LinearMap.id ββ mono... |
import Mathlib.RingTheory.Localization.Module
import Mathlib.RingTheory.Norm
import Mathlib.RingTheory.Discriminant
#align_import ring_theory.localization.norm from "leanprover-community/mathlib"@"2e59a6de168f95d16b16d217b808a36290398c0a"
open scoped nonZeroDivisors
variable (R : Type*) {S : Type*} [CommRing R] ... | Mathlib/RingTheory/Localization/NormTrace.lean | 61 | 69 | theorem Algebra.norm_localization [Module.Free R S] [Module.Finite R S] (a : S) :
Algebra.norm Rβ (algebraMap S Sβ a) = algebraMap R Rβ (Algebra.norm R a) := by |
cases subsingleton_or_nontrivial R
Β· haveI : Subsingleton Rβ := Module.subsingleton R Rβ
simp [eq_iff_true_of_subsingleton]
let b := Module.Free.chooseBasis R S
letI := Classical.decEq (Module.Free.ChooseBasisIndex R S)
rw [Algebra.norm_eq_matrix_det (b.localizationLocalization Rβ M Sβ),
Algebra.norm... | [
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a)",
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) i j =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a) i j",
" (norm Rβ) ((algebr... | [
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a)",
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) i j =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a) i j"
] |
import Mathlib.Algebra.MvPolynomial.Derivation
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.pderiv from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
universe u v
namespace MvPolynomial
open Set Function Finsupp
variable {R : ... | Mathlib/Algebra/MvPolynomial/PDeriv.lean | 89 | 91 | theorem pderiv_X [DecidableEq Ο] (i j : Ο) :
pderiv i (X j : MvPolynomial Ο R) = Pi.single (f := fun j => _) i 1 j := by |
rw [pderiv_def, mkDerivation_X]
| [
" pderiv i = mkDerivation R (Pi.single i 1)",
" mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)",
" (pderiv i) ((monomial s) a) = (monomial (s - single i 1)) (a * β(s i))",
" (s.sum fun a_1 b => (monomial (s - single a_1 1)) (a * βb) * Pi.single i 1 a_1) =\n (monomial (s - single i 1)) (a *... | [
" pderiv i = mkDerivation R (Pi.single i 1)",
" mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)",
" (pderiv i) ((monomial s) a) = (monomial (s - single i 1)) (a * β(s i))",
" (s.sum fun a_1 b => (monomial (s - single a_1 1)) (a * βb) * Pi.single i 1 a_1) =\n (monomial (s - single i 1)) (a *... |
import Mathlib.Data.Finset.Fold
import Mathlib.Algebra.GCDMonoid.Multiset
#align_import algebra.gcd_monoid.finset from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
#align_import algebra.gcd_monoid.div from "leanprover-community/mathlib"@"b537794f8409bc9598febb79cd510b1df5f4539d"
variab... | Mathlib/Algebra/GCDMonoid/Finset.lean | 203 | 205 | theorem gcd_image [DecidableEq Ξ²] {g : Ξ³ β Ξ²} (s : Finset Ξ³) :
(s.image g).gcd f = s.gcd (f β g) := by |
classical induction' s using Finset.induction with c s _ ih <;> simp [*]
| [
" a β£ s.gcd f β β b β s, a β£ f b",
" (β b β Multiset.map f s.val, a β£ b) β β b β s, a β£ f b",
" (β (b : Ξ±), β x β s.val, f x = b β a β£ b) β β b β s, a β£ f b",
" (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)",
" normalize (s.gcd f) = s.gcd f",
" (β
βͺ sβ).gcd f = GCDMonoid.gcd (β
.gcd f) (sβ.gcd f)",
... | [
" a β£ s.gcd f β β b β s, a β£ f b",
" (β b β Multiset.map f s.val, a β£ b) β β b β s, a β£ f b",
" (β (b : Ξ±), β x β s.val, f x = b β a β£ b) β β b β s, a β£ f b",
" (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)",
" normalize (s.gcd f) = s.gcd f",
" (β
βͺ sβ).gcd f = GCDMonoid.gcd (β
.gcd f) (sβ.gcd f)",
... |
import Mathlib.Analysis.Calculus.MeanValue
import Mathlib.Analysis.NormedSpace.RCLike
import Mathlib.Order.Filter.Curry
#align_import analysis.calculus.uniform_limits_deriv from "leanprover-community/mathlib"@"3f655f5297b030a87d641ad4e825af8d9679eb0b"
open Filter
open scoped uniformity Filter Topology
section L... | Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean | 112 | 163 | theorem uniformCauchySeqOnFilter_of_fderiv (hf' : UniformCauchySeqOnFilter f' l (π x))
(hf : βαΆ n : ΞΉ Γ E in l ΓΛ’ π x, HasFDerivAt (f n.1) (f' n.1 n.2) n.2)
(hfg : Cauchy (map (fun n => f n x) l)) : UniformCauchySeqOnFilter f l (π x) := by |
letI : NormedSpace β E := NormedSpace.restrictScalars β π _
rw [SeminormedAddGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_zero] at hf' β’
suffices
TendstoUniformlyOnFilter (fun (n : ΞΉ Γ ΞΉ) (z : E) => f n.1 z - f n.2 z - (f n.1 x - f n.2 x)) 0
(l ΓΛ’ l) (π x) β§
TendstoUniformlyOnF... | [
" UniformCauchySeqOnFilter f l (π x)",
" TendstoUniformlyOnFilter (fun n z => f n.1 z - f n.2 z) 0 (l ΓΛ’ l) (π x)",
" βαΆ (n : (ΞΉ Γ ΞΉ) Γ E) in (l ΓΛ’ l) ΓΛ’ π x,\n ((fun n z => f n.1 z - f n.2 z - (f n.1 x - f n.2 x)) + fun n x_1 => f n.1 x - f n.2 x) n.1 n.2 =\n f n.1.1 n.2 - f n.1.2 n.2",
" TendstoU... | [] |
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
import Mathlib.Topology.Order.ProjIcc
#align_import analysis.special_functions.trigonometric.inverse from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Topology Filter
open S... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean | 64 | 66 | theorem sin_arcsin' {x : β} (hx : x β Icc (-1 : β) 1) : sin (arcsin x) = x := by |
simpa [arcsin, IccExtend_of_mem _ _ hx, -OrderIso.apply_symm_apply] using
Subtype.ext_iff.1 (sinOrderIso.apply_symm_apply β¨x, hxβ©)
| [
" range arcsin = Icc (-(Ο / 2)) (Ο / 2)",
" Subtype.val '' range (IccExtend arcsin.proof_2 βsinOrderIso.symm) = Icc (-(Ο / 2)) (Ο / 2)",
" (β(projIcc (-1) 1 β― x)).arcsin = x.arcsin",
" x.arcsin.sin = x"
] | [
" range arcsin = Icc (-(Ο / 2)) (Ο / 2)",
" Subtype.val '' range (IccExtend arcsin.proof_2 βsinOrderIso.symm) = Icc (-(Ο / 2)) (Ο / 2)",
" (β(projIcc (-1) 1 β― x)).arcsin = x.arcsin"
] |
import Mathlib.Algebra.ContinuedFractions.Computation.Basic
import Mathlib.Algebra.ContinuedFractions.Translations
#align_import algebra.continued_fractions.computation.translations from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace GeneralizedContinuedFraction
open Generali... | Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean | 112 | 121 | theorem exists_succ_nth_stream_of_fr_zero {ifp_succ_n : IntFractPair K}
(stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n)
(succ_nth_fr_eq_zero : ifp_succ_n.fr = 0) :
β ifp_n : IntFractPair K, IntFractPair.stream v n = some ifp_n β§ ifp_n.frβ»ΒΉ = βifp_n.frβ»ΒΉβ := by |
-- get the witness from `succ_nth_stream_eq_some_iff` and prove that it has the additional
-- properties
rcases succ_nth_stream_eq_some_iff.mp stream_succ_nth_eq with
β¨ifp_n, seq_nth_eq, _, rflβ©
refine β¨ifp_n, seq_nth_eq, ?_β©
simpa only [IntFractPair.of, Int.fract, sub_eq_zero] using succ_nth_fr_eq_zero
| [
" IntFractPair.stream v (n + 1) = none",
" IntFractPair.stream v (n + 1) = none β\n IntFractPair.stream v n = none β¨ β ifp, IntFractPair.stream v n = some ifp β§ ifp.fr = 0",
" ((IntFractPair.stream v n).bind fun ap_n => if ap_n.fr = 0 then none else some (IntFractPair.of ap_n.frβ»ΒΉ)) = none β\n IntFractPai... | [
" IntFractPair.stream v (n + 1) = none",
" IntFractPair.stream v (n + 1) = none β\n IntFractPair.stream v n = none β¨ β ifp, IntFractPair.stream v n = some ifp β§ ifp.fr = 0",
" ((IntFractPair.stream v n).bind fun ap_n => if ap_n.fr = 0 then none else some (IntFractPair.of ap_n.frβ»ΒΉ)) = none β\n IntFractPai... |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 120 | 122 | theorem count_le_cardinal (n : β) : (count p n : Cardinal) β€ Cardinal.mk { k | p k } := by |
rw [count_eq_card_fintype, β Cardinal.mk_fintype]
exact Cardinal.mk_subtype_mono fun x hx β¦ hx.2
| [
" count p 0 = 0",
" Fintype { i // i < n β§ p i }",
" β (x : β), x β filter p (range n) β x β fun x => x < n β§ p x",
" x β filter p (range n) β x β fun x => x < n β§ p x",
" x < n β§ p x β x β fun x => x < n β§ p x",
" count p n = (filter p (range n)).card",
" (List.filter (fun b => decide (p b)) (List.rang... | [
" count p 0 = 0",
" Fintype { i // i < n β§ p i }",
" β (x : β), x β filter p (range n) β x β fun x => x < n β§ p x",
" x β filter p (range n) β x β fun x => x < n β§ p x",
" x < n β§ p x β x β fun x => x < n β§ p x",
" count p n = (filter p (range n)).card",
" (List.filter (fun b => decide (p b)) (List.rang... |
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace Tens... | Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 93 | 98 | theorem gradedCommAux_comp_gradedCommAux :
gradedCommAux R π β¬ ββ gradedCommAux R β¬ π = LinearMap.id := by |
ext i a b
dsimp
rw [gradedCommAux_lof_tmul, LinearMap.map_smul_of_tower, gradedCommAux_lof_tmul, smul_smul,
mul_comm i.2 i.1, Int.units_mul_self, one_smul]
| [
" (β¨ (i : ΞΉ Γ ΞΉ), π i.1 β[R] β¬ i.2) ββ[R] β¨ (i : ΞΉ Γ ΞΉ), β¬ i.1 β[R] π i.2",
" π i.1 β[R] β¬ i.2 ββ[R] β¨ (i : ΞΉ Γ ΞΉ), β¬ i.1 β[R] π i.2",
" (gradedCommAux R π β¬) ((lof R (ΞΉ Γ ΞΉ) (fun i => π i.1 β[R] β¬ i.2) (i, j)) (a ββ[R] b)) =\n (-1) ^ (j * i) β’ (lof R (ΞΉ Γ ΞΉ) (fun i => β¬ i.1 β[R] π i.2) (j, i)) (b ββ[... | [
" (β¨ (i : ΞΉ Γ ΞΉ), π i.1 β[R] β¬ i.2) ββ[R] β¨ (i : ΞΉ Γ ΞΉ), β¬ i.1 β[R] π i.2",
" π i.1 β[R] β¬ i.2 ββ[R] β¨ (i : ΞΉ Γ ΞΉ), β¬ i.1 β[R] π i.2",
" (gradedCommAux R π β¬) ((lof R (ΞΉ Γ ΞΉ) (fun i => π i.1 β[R] β¬ i.2) (i, j)) (a ββ[R] b)) =\n (-1) ^ (j * i) β’ (lof R (ΞΉ Γ ΞΉ) (fun i => β¬ i.1 β[R] π i.2) (j, i)) (b ββ[... |
import Mathlib.Algebra.Group.Aut
import Mathlib.Algebra.Group.Invertible.Basic
import Mathlib.Algebra.GroupWithZero.Units.Basic
import Mathlib.GroupTheory.GroupAction.Units
#align_import group_theory.group_action.group from "leanprover-community/mathlib"@"3b52265189f3fb43aa631edffce5d060fafaf82f"
universe u v w
... | Mathlib/GroupTheory/GroupAction/Group.lean | 30 | 30 | theorem inv_smul_smul (c : Ξ±) (x : Ξ²) : cβ»ΒΉ β’ c β’ x = x := by | rw [smul_smul, mul_left_inv, one_smul]
| [
" cβ»ΒΉ β’ c β’ x = x"
] | [] |
import Mathlib.Geometry.Euclidean.Inversion.Basic
import Mathlib.Geometry.Euclidean.PerpBisector
open Metric Function AffineMap Set AffineSubspace
open scoped Topology
variable {V P : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] [MetricSpace P]
[NormedAddTorsor V P] {c x y : P} {R : β}
namespace Euclid... | Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean | 61 | 64 | theorem image_inversion_perpBisector (hR : R β 0) (hy : y β c) :
inversion c R '' perpBisector c y = sphere (inversion c R y) (R ^ 2 / dist y c) \ {c} := by |
rw [image_eq_preimage_of_inverse (inversion_involutive _ hR) (inversion_involutive _ hR),
preimage_inversion_perpBisector hR hy]
| [
" inversion c R x β perpBisector c (inversion c R y) β dist x y = dist y c",
" R ^ 2 / dist x c = R ^ 2 / (dist x c * dist y c) * dist x y β dist x y = dist y c",
" inversion c R x β perpBisector c (inversion c R y) β dist x y = dist y c β§ x β c",
" inversion x R x β perpBisector x (inversion x R y) β dist x ... | [
" inversion c R x β perpBisector c (inversion c R y) β dist x y = dist y c",
" R ^ 2 / dist x c = R ^ 2 / (dist x c * dist y c) * dist x y β dist x y = dist y c",
" inversion c R x β perpBisector c (inversion c R y) β dist x y = dist y c β§ x β c",
" inversion x R x β perpBisector x (inversion x R y) β dist x ... |
import Mathlib.Order.Filter.Prod
#align_import order.filter.n_ary from "leanprover-community/mathlib"@"78f647f8517f021d839a7553d5dc97e79b508dea"
open Function Set
open Filter
namespace Filter
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' : Type*} {m : Ξ± β Ξ² β Ξ³} {f fβ fβ : Filter Ξ±}
{g gβ gβ : Filter Ξ²} {h hβ hβ : Filt... | Mathlib/Order/Filter/NAry.lean | 103 | 103 | theorem mapβ_neBot_iff : (mapβ m f g).NeBot β f.NeBot β§ g.NeBot := by | simp [neBot_iff, not_or]
| [
" xβ β {s | β u β f, β v β g, image2 m u v β s} β xβ β map (uncurry m) (f ΓΛ’ g)",
" xβ β {s | β u β f, β v β g, β x β u, β y β v, m x y β s} β\n β tβ β f, β tβ β g, β x β tβ, β y β tβ, (x, y) β uncurry m β»ΒΉ' xβ",
" map (fun p => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g",
" mapβ Prod.mk f g = f ΓΛ’ g",
" mapβ m f ... | [
" xβ β {s | β u β f, β v β g, image2 m u v β s} β xβ β map (uncurry m) (f ΓΛ’ g)",
" xβ β {s | β u β f, β v β g, β x β u, β y β v, m x y β s} β\n β tβ β f, β tβ β g, β x β tβ, β y β tβ, (x, y) β uncurry m β»ΒΉ' xβ",
" map (fun p => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g",
" mapβ Prod.mk f g = f ΓΛ’ g",
" mapβ m f ... |
import Mathlib.Data.ZMod.Quotient
import Mathlib.GroupTheory.NoncommPiCoprod
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Algebra.GCDMonoid.Finset
import Mathlib.Algebra.GCDMonoid.Nat
import Mathlib.Data.Nat.Factorization.Basic
import Mathlib.Tactic.ByContra
import Mathlib.Tactic.Peel
#align_import group_... | Mathlib/GroupTheory/Exponent.lean | 160 | 163 | theorem pow_eq_mod_exponent {n : β} (g : G) : g ^ n = g ^ (n % exponent G) :=
calc
g ^ n = g ^ (n % exponent G + exponent G * (n / exponent G)) := by | rw [Nat.mod_add_div]
_ = g ^ (n % exponent G) := by simp [pow_add, pow_mul, pow_exponent_eq_one]
| [
" Monoid.exponent Gα΅α΅α΅ = Monoid.exponent G",
" (if h : β n, 0 < n β§ β (g : Gα΅α΅α΅), g ^ n = 1 then Nat.find h else 0) =\n if h : β n, 0 < n β§ β (g : G), g ^ n = 1 then Nat.find h else 0",
" (β (g : Gα΅α΅α΅), g ^ xβ = 1) β β (g : G), g ^ xβ = 1",
" β n, 0 < n β§ g ^ n = 1",
" g ^ nβ = 1",
" exponent G β 0 β E... | [
" Monoid.exponent Gα΅α΅α΅ = Monoid.exponent G",
" (if h : β n, 0 < n β§ β (g : Gα΅α΅α΅), g ^ n = 1 then Nat.find h else 0) =\n if h : β n, 0 < n β§ β (g : G), g ^ n = 1 then Nat.find h else 0",
" (β (g : Gα΅α΅α΅), g ^ xβ = 1) β β (g : G), g ^ xβ = 1",
" β n, 0 < n β§ g ^ n = 1",
" g ^ nβ = 1",
" exponent G β 0 β E... |
import Mathlib.RingTheory.RootsOfUnity.Basic
universe u
variable {L : Type u} [CommRing L] [IsDomain L]
variable (n : β+)
theorem rootsOfUnity.integer_power_of_ringEquiv (g : L β+* L) :
β m : β€, β t : rootsOfUnity n L, g (t : LΛ£) = (t ^ m : LΛ£) := by
obtain β¨m, hmβ© := MonoidHom.map_cyclic ((g : L β* L).re... | Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean | 77 | 79 | theorem rootsOfUnity.integer_power_of_ringEquiv' (g : L β+* L) :
β m : β€, β t β rootsOfUnity n L, g (t : LΛ£) = (t ^ m : LΛ£) := by |
simpa using rootsOfUnity.integer_power_of_ringEquiv n g
| [
" β m, β (t : β₯(rootsOfUnity n L)), g ββt = β(βt ^ m)",
" β m, β t β rootsOfUnity n L, g βt = β(t ^ m)"
] | [
" β m, β (t : β₯(rootsOfUnity n L)), g ββt = β(βt ^ m)"
] |
import Mathlib.Order.Interval.Set.UnorderedInterval
import Mathlib.Algebra.Order.Interval.Set.Monoid
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Group.MinMax
#align_import data.set.pointwise.interval from "leanprover-community/mathlib"@"2196ab363eb097c... | Mathlib/Data/Set/Pointwise/Interval.lean | 98 | 101 | theorem Iio_mul_Iic_subset' (a b : Ξ±) : Iio a * Iic b β Iio (a * b) := by |
haveI := covariantClass_le_of_lt
rintro x β¨y, hya, z, hzb, rflβ©
exact mul_lt_mul_of_lt_of_le hya hzb
| [
" Icc a b * Ico c d β Ico (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z β Ico (a * c) (b * d)",
" Ico a b * Icc c d β Ico (a * c) (b * d)",
" Ioc a b * Ico c d β Ioo (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z β Ioo (a * c) (b * d)",
" Ico a b * Ioc c d β Ioo (a * c) (b * d)",
" Iic a * Iio b β Iio ... | [
" Icc a b * Ico c d β Ico (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z β Ico (a * c) (b * d)",
" Ico a b * Icc c d β Ico (a * c) (b * d)",
" Ioc a b * Ico c d β Ioo (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z β Ioo (a * c) (b * d)",
" Ico a b * Ioc c d β Ioo (a * c) (b * d)",
" Iic a * Iio b β Iio ... |
import Mathlib.Data.Fintype.Card
import Mathlib.Computability.Language
import Mathlib.Tactic.NormNum
#align_import computability.DFA from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
open Computability
universe u v
-- Porting note: Required as `DFA` is used in mathlib3
set_option li... | Mathlib/Computability/DFA.lean | 101 | 134 | theorem evalFrom_split [Fintype Ο] {x : List Ξ±} {s t : Ο} (hlen : Fintype.card Ο β€ x.length)
(hx : M.evalFrom s x = t) :
β q a b c,
x = a ++ b ++ c β§
a.length + b.length β€ Fintype.card Ο β§
b β [] β§ M.evalFrom s a = q β§ M.evalFrom q b = q β§ M.evalFrom q c = t := by |
obtain β¨n, m, hneq, heqβ© :=
Fintype.exists_ne_map_eq_of_card_lt
(fun n : Fin (Fintype.card Ο + 1) => M.evalFrom s (x.take n)) (by norm_num)
wlog hle : (n : β) β€ m
Β· exact this _ hlen hx _ _ hneq.symm heq.symm (le_of_not_le hle)
have hm : (m : β) β€ Fintype.card Ο := Fin.is_le m
refine
β¨M.evalFro... | [
" M.evalFrom s (x ++ [a]) = M.step (M.evalFrom s x) a",
" x β M.accepts β M.evalFrom M.start x β M.accept",
" β q a b c,\n x = a ++ b ++ c β§\n a.length + b.length β€ Fintype.card Ο β§ b β [] β§ M.evalFrom s a = q β§ M.evalFrom q b = q β§ M.evalFrom q c = t",
" Fintype.card Ο < Fintype.card (Fin (Fintype.ca... | [
" M.evalFrom s (x ++ [a]) = M.step (M.evalFrom s x) a",
" x β M.accepts β M.evalFrom M.start x β M.accept"
] |
import Mathlib.CategoryTheory.Sites.Sheaf
#align_import category_theory.sites.canonical from "leanprover-community/mathlib"@"9e7c80f638149bfb3504ba8ff48dfdbfc949fb1a"
universe v u
namespace CategoryTheory
open scoped Classical
open CategoryTheory Category Limits Sieve
variable {C : Type u} [Category.{v} C]
na... | Mathlib/CategoryTheory/Sites/Canonical.lean | 61 | 113 | theorem isSheafFor_bind (P : Cα΅α΅ β₯€ Type v) (U : Sieve X) (B : β β¦Yβ¦ β¦f : Y βΆ Xβ¦, U f β Sieve Y)
(hU : Presieve.IsSheafFor P (U : Presieve X))
(hB : β β¦Yβ¦ β¦f : Y βΆ Xβ¦ (hf : U f), Presieve.IsSheafFor P (B hf : Presieve Y))
(hB' : β β¦Yβ¦ β¦f : Y βΆ Xβ¦ (h : U f) β¦Zβ¦ (g : Z βΆ Y),
Presieve.IsSeparatedFor P (((... |
intro s hs
let y : β β¦Yβ¦ β¦f : Y βΆ Xβ¦ (hf : U f), Presieve.FamilyOfElements P (B hf : Presieve Y) :=
fun Y f hf Z g hg => s _ (Presieve.bind_comp _ _ hg)
have hy : β β¦Yβ¦ β¦f : Y βΆ Xβ¦ (hf : U f), (y hf).Compatible := by
intro Y f H Yβ Yβ Z gβ gβ fβ fβ hfβ hfβ comm
apply hs
apply reassoc_of% comm
l... | [
" Presieve.IsSheafFor P (Sieve.bind U.arrows B).arrows",
" β! t, s.IsAmalgamation t",
" β β¦Y : Cβ¦ β¦f : Y βΆ Xβ¦ (hf : U.arrows f), (y hf).Compatible",
" P.map gβ.op (y H fβ hfβ) = P.map gβ.op (y H fβ hfβ)",
" gβ β« fβ β« f = gβ β« fβ β« f",
" t.Compatible",
" t.SieveCompatible",
" t (h β« f) β― = P.map h.op (... | [] |
import Mathlib.Analysis.BoxIntegral.Partition.Filter
import Mathlib.Analysis.BoxIntegral.Partition.Measure
import Mathlib.Topology.UniformSpace.Compact
import Mathlib.Init.Data.Bool.Lemmas
#align_import analysis.box_integral.basic from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open... | Mathlib/Analysis/BoxIntegral/Basic.lean | 83 | 87 | theorem integralSum_biUnionTagged (f : ββΏ β E) (vol : ΞΉ βα΅α΅ E βL[β] F) (Ο : Prepartition I)
(Οi : β J, TaggedPrepartition J) :
integralSum f vol (Ο.biUnionTagged Οi) = β J β Ο.boxes, integralSum f vol (Οi J) := by |
refine (Ο.sum_biUnion_boxes _ _).trans <| sum_congr rfl fun J hJ => sum_congr rfl fun J' hJ' => ?_
rw [Ο.tag_biUnionTagged hJ hJ']
| [
" integralSum f vol (Ο.biUnionTagged Οi) = β J β Ο.boxes, integralSum f vol (Οi J)",
" (vol J') (f ((Ο.biUnionTagged Οi).tag J')) = (vol J') (f ((Οi J).tag J'))"
] | [] |
import Mathlib.Algebra.Associated
import Mathlib.Algebra.BigOperators.Finsupp
#align_import algebra.big_operators.associated from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
variable {Ξ± Ξ² Ξ³ Ξ΄ : Type*}
-- the same local notation used in `Algebra.Associated`
local infixl:50 " ~α΅€ " => ... | Mathlib/Algebra/BigOperators/Associated.lean | 58 | 69 | theorem Associated.prod {M : Type*} [CommMonoid M] {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β M)
(g : ΞΉ β M) (h : β i, i β s β (f i) ~α΅€ (g i)) : (β i β s, f i) ~α΅€ (β i β s, g i) := by |
induction s using Finset.induction with
| empty =>
simp only [Finset.prod_empty]
rfl
| @insert j s hjs IH =>
classical
convert_to (β i β insert j s, f i) ~α΅€ (β i β insert j s, g i)
rw [Finset.prod_insert hjs, Finset.prod_insert hjs]
exact Associated.mul_mul (h j (Finset.mem_insert_self j ... | [
" β i β s, f i ~α΅€ β i β s, g i",
" β i β β
, f i ~α΅€ β i β β
, g i",
" 1 ~α΅€ 1",
" β i β insert j s, f i ~α΅€ β i β insert j s, g i",
" f j * β x β s, f x ~α΅€ g j * β x β s, g x"
] | [] |
import Mathlib.CategoryTheory.Abelian.Opposite
import Mathlib.CategoryTheory.Abelian.Homology
import Mathlib.Algebra.Homology.Additive
import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
#align_import algebra.homology.opposite from "leanprover-community/mathlib"@"8c75ef3517d4106e89fe524e6281d0b0545f47fc"
... | Mathlib/Algebra/Homology/Opposite.lean | 40 | 50 | theorem imageToKernel_op {X Y Z : V} (f : X βΆ Y) (g : Y βΆ Z) (w : f β« g = 0) :
imageToKernel g.op f.op (by rw [β op_comp, w, op_zero]) =
(imageSubobjectIso _ βͺβ« (imageOpOp _).symm).hom β«
(cokernel.desc f (factorThruImage g)
(by rw [β cancel_mono (image.ΞΉ g), Category.assoc, image.fac, w,... |
ext
simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelOpOp_inv, Category.assoc,
imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ΞΉ, β op_comp, cokernel.Ο_desc,
β imageSubobject_arrow, β imageUnopOp_inv_comp_op_factorThruImage g.op]
rfl
| [
" g.op β« f.op = 0",
" f β« factorThruImage g = 0",
" imageToKernel g.op f.op β― =\n (imageSubobjectIso g.op βͺβ« (imageOpOp g).symm).hom β«\n (cokernel.desc f (factorThruImage g) β―).op β« (kernelSubobjectIso f.op βͺβ« kernelOpOp f).inv",
" imageToKernel g.op f.op β― β« (kernelSubobject f.op).arrow =\n ((imag... | [] |
import Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform
import Mathlib.Analysis.Fourier.PoissonSummation
open Real Set MeasureTheory Filter Asymptotics intervalIntegral
open scoped Real Topology FourierTransform RealInnerProductSpace
open Complex hiding exp continuous_exp abs_of_nonneg sq_abs
noncomp... | Mathlib/Analysis/SpecialFunctions/Gaussian/PoissonSummation.lean | 68 | 76 | theorem tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact {a : β} (ha : 0 < a) (s : β) :
Tendsto (fun x : β => |x| ^ s * rexp (-a * x ^ 2)) (cocompact β) (π 0) := by |
conv in rexp _ => rw [β sq_abs]
erw [cocompact_eq_atBot_atTop, β comap_abs_atTop,
@tendsto_comap'_iff _ _ _ (fun y => y ^ s * rexp (-a * y ^ 2)) _ _ _
(mem_atTop_sets.mpr β¨0, fun b hb => β¨b, abs_of_nonneg hbβ©β©)]
exact
(rpow_mul_exp_neg_mul_sq_isLittleO_exp_neg ha s).tendsto_zero_of_tendsto
(t... | [
" (fun x => rexp (a * x ^ 2 + b * x)) =o[atTop] fun x => x ^ s",
" (fun x => rexp (-x)) =o[atTop] fun x => x ^ s",
" (fun x => rexp (a * x ^ 2 + b * x)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - (a * x ^ 2 + b * x)) atTop atTop",
" (fun x => -x - (a * x ^ 2 + b * x)) = fun x => x * (-a * x - (... | [
" (fun x => rexp (a * x ^ 2 + b * x)) =o[atTop] fun x => x ^ s",
" (fun x => rexp (-x)) =o[atTop] fun x => x ^ s",
" (fun x => rexp (a * x ^ 2 + b * x)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - (a * x ^ 2 + b * x)) atTop atTop",
" (fun x => -x - (a * x ^ 2 + b * x)) = fun x => x * (-a * x - (... |
import Mathlib.Topology.UniformSpace.CompleteSeparated
import Mathlib.Topology.EMetricSpace.Lipschitz
import Mathlib.Topology.MetricSpace.Basic
import Mathlib.Topology.MetricSpace.Bounded
#align_import topology.metric_space.antilipschitz from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
... | Mathlib/Topology/MetricSpace/Antilipschitz.lean | 129 | 134 | theorem comp {Kg : ββ₯0} {g : Ξ² β Ξ³} (hg : AntilipschitzWith Kg g) {Kf : ββ₯0} {f : Ξ± β Ξ²}
(hf : AntilipschitzWith Kf f) : AntilipschitzWith (Kf * Kg) (g β f) := fun x y =>
calc
edist x y β€ Kf * edist (f x) (f y) := hf x y
_ β€ Kf * (Kg * edist (g (f x)) (g (f y))) := ENNReal.mul_left_mono (hg _ _)
_ = _... | rw [ENNReal.coe_mul, mul_assoc]; rfl
| [
" AntilipschitzWith K f β β (x y : Ξ±), nndist x y β€ K * nndist (f x) (f y)",
" (β (x y : Ξ±), β(nndist x y) β€ βK * β(nndist (f x) (f y))) β β (x y : Ξ±), nndist x y β€ K * nndist (f x) (f y)",
" AntilipschitzWith K f β β (x y : Ξ±), dist x y β€ βK * dist (f x) (f y)",
" (β (x y : Ξ±), nndist x y β€ K * nndist (f x) ... | [
" AntilipschitzWith K f β β (x y : Ξ±), nndist x y β€ K * nndist (f x) (f y)",
" (β (x y : Ξ±), β(nndist x y) β€ βK * β(nndist (f x) (f y))) β β (x y : Ξ±), nndist x y β€ K * nndist (f x) (f y)",
" AntilipschitzWith K f β β (x y : Ξ±), dist x y β€ βK * dist (f x) (f y)",
" (β (x y : Ξ±), nndist x y β€ K * nndist (f x) ... |
import Mathlib.Topology.Separation
#align_import topology.sober from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
open Set
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [TopologicalSpace Ξ²]
section genericPoint
def IsGenericPoint (x : Ξ±) (S : Set Ξ±) : Prop :=
closure ({x} : Set Ξ±)... | Mathlib/Topology/Sober.lean | 148 | 150 | theorem genericPoint_spec [QuasiSober Ξ±] [IrreducibleSpace Ξ±] :
IsGenericPoint (genericPoint Ξ±) β€ := by |
simpa using (IrreducibleSpace.isIrreducible_univ Ξ±).genericPoint_spec
| [
" IsGenericPoint x S β β (y : Ξ±), x β€³ y β y β S",
" IsGenericPoint (genericPoint Ξ±) β€"
] | [
" IsGenericPoint x S β β (y : Ξ±), x β€³ y β y β S"
] |
import Mathlib.Algebra.Polynomial.FieldDivision
import Mathlib.FieldTheory.Minpoly.Basic
import Mathlib.RingTheory.Algebraic
#align_import field_theory.minpoly.field from "leanprover-community/mathlib"@"cbdf7b565832144d024caa5a550117c6df0204a5"
open scoped Classical
open Polynomial Set Function minpoly
namespace... | Mathlib/FieldTheory/Minpoly/Field.lean | 93 | 99 | theorem dvd_map_of_isScalarTower' (R : Type*) {S : Type*} (K L : Type*) [CommRing R]
[CommRing S] [Field K] [CommRing L] [Algebra R S] [Algebra R K] [Algebra S L] [Algebra K L]
[Algebra R L] [IsScalarTower R K L] [IsScalarTower R S L] (s : S) :
minpoly K (algebraMap S L s) β£ map (algebraMap R K) (minpoly R ... |
apply minpoly.dvd K (algebraMap S L s)
rw [β map_aeval_eq_aeval_map, minpoly.aeval, map_zero]
rw [β IsScalarTower.algebraMap_eq, β IsScalarTower.algebraMap_eq]
| [
" (Polynomial.aeval x) (p * C p.leadingCoeffβ»ΒΉ) = 0",
" p = minpoly A x",
" minpoly A x = p",
" minpoly A x - p = 0",
" False",
" (Polynomial.aeval x) (minpoly A x - p) = 0",
" (minpoly A x - p).degree < (minpoly A x).degree",
" (minpoly A x).leadingCoeff = p.leadingCoeff",
" (minpoly A x).degree = ... | [
" (Polynomial.aeval x) (p * C p.leadingCoeffβ»ΒΉ) = 0",
" p = minpoly A x",
" minpoly A x = p",
" minpoly A x - p = 0",
" False",
" (Polynomial.aeval x) (minpoly A x - p) = 0",
" (minpoly A x - p).degree < (minpoly A x).degree",
" (minpoly A x).leadingCoeff = p.leadingCoeff",
" (minpoly A x).degree = ... |
import Mathlib.Dynamics.PeriodicPts
import Mathlib.GroupTheory.Exponent
import Mathlib.GroupTheory.GroupAction.Basic
namespace MulAction
universe u v
variable {Ξ± : Type v}
variable {G : Type u} [Group G] [MulAction G Ξ±]
variable {M : Type u} [Monoid M] [MulAction M Ξ±]
@[to_additive "If the action is periodic, t... | Mathlib/GroupTheory/GroupAction/Period.lean | 71 | 75 | theorem period_inv (g : G) (a : Ξ±) : period gβ»ΒΉ a = period g a := by |
simp only [period_eq_minimalPeriod, Function.minimalPeriod_eq_minimalPeriod_iff,
isPeriodicPt_smul_iff]
intro n
rw [smul_eq_iff_eq_inv_smul, eq_comm, β zpow_natCast, inv_zpow, inv_inv, zpow_natCast]
| [
" m ^ 1 β’ a = a",
" period gβ»ΒΉ a = period g a",
" β (n : β), gβ»ΒΉ ^ n β’ a = a β g ^ n β’ a = a",
" gβ»ΒΉ ^ n β’ a = a β g ^ n β’ a = a"
] | [
" m ^ 1 β’ a = a"
] |
import Mathlib.Data.Setoid.Partition
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.GroupAction.Pointwise
import Mathlib.GroupTheory.GroupAction.SubMulAction
open scoped BigOperators Pointwise
namespace MulAction
section orbits
variable {G : Type*} [Group G] {X : Type*} [MulAction G X]
... | Mathlib/GroupTheory/GroupAction/Blocks.lean | 44 | 48 | theorem orbit.pairwiseDisjoint :
(Set.range fun x : X => orbit G x).PairwiseDisjoint id := by |
rintro s β¨x, rflβ© t β¨y, rflβ© h
contrapose! h
exact (orbit.eq_or_disjoint x y).resolve_right h
| [
" orbit G a = orbit G b β¨ Disjoint (orbit G a) (orbit G b)",
" Β¬Disjoint (orbit G a) (orbit G b) β orbit G a = orbit G b",
" (Set.range fun x => orbit G x).PairwiseDisjoint id",
" (Disjoint on id) ((fun x => orbit G x) x) ((fun x => orbit G x) y)",
" orbit G x = orbit G y"
] | [
" orbit G a = orbit G b β¨ Disjoint (orbit G a) (orbit G b)",
" Β¬Disjoint (orbit G a) (orbit G b) β orbit G a = orbit G b"
] |
import Mathlib.Data.Matrix.Invertible
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
import Mathlib.LinearAlgebra.Matrix.PosDef
#align_import linear_algebra.matrix.schur_complement from "leanprover-community/mathlib"@"a176cb1219e300e85793d44583dede42377b51af"
variable {l m n Ξ± : Type*}
namespace Matrix
... | Mathlib/LinearAlgebra/Matrix/SchurComplement.lean | 454 | 459 | theorem det_add_col_mul_row {A : Matrix m m Ξ±} (hA : IsUnit A.det) (u v : m β Ξ±) :
(A + col u * row v).det = A.det * (1 + row v * Aβ»ΒΉ * col u).det := by |
nth_rewrite 1 [β Matrix.mul_one A]
rwa [β Matrix.mul_nonsing_inv_cancel_left A (col u * row v),
β Matrix.mul_add, det_mul, β Matrix.mul_assoc, det_one_add_mul_comm,
β Matrix.mul_assoc]
| [
" A.fromBlocks B C D = fromBlocks 1 0 (C * β
A) 1 * A.fromBlocks 0 0 (D - C * β
A * B) * fromBlocks 1 (β
A * B) 0 1",
" (reindex (Equiv.sumComm l n) (Equiv.sumComm m n)) (A.fromBlocks B C D) =\n (reindex (Equiv.sumComm l n) (Equiv.sumComm m n))\n (fromBlocks 1 (B * β
D) 0 1 * (A - B * β
D * C).fromBlocks 0 0 D... | [
" A.fromBlocks B C D = fromBlocks 1 0 (C * β
A) 1 * A.fromBlocks 0 0 (D - C * β
A * B) * fromBlocks 1 (β
A * B) 0 1",
" (reindex (Equiv.sumComm l n) (Equiv.sumComm m n)) (A.fromBlocks B C D) =\n (reindex (Equiv.sumComm l n) (Equiv.sumComm m n))\n (fromBlocks 1 (B * β
D) 0 1 * (A - B * β
D * C).fromBlocks 0 0 D... |
import Mathlib.MeasureTheory.Measure.Sub
import Mathlib.MeasureTheory.Decomposition.SignedHahn
import Mathlib.MeasureTheory.Function.AEEqOfIntegral
#align_import measure_theory.decomposition.lebesgue from "leanprover-community/mathlib"@"b2ff9a3d7a15fd5b0f060b135421d6a89a999c2f"
open scoped MeasureTheory NNReal ENN... | Mathlib/MeasureTheory/Decomposition/Lebesgue.lean | 86 | 90 | theorem haveLebesgueDecomposition_spec (ΞΌ Ξ½ : Measure Ξ±) [h : HaveLebesgueDecomposition ΞΌ Ξ½] :
Measurable (ΞΌ.rnDeriv Ξ½) β§
ΞΌ.singularPart Ξ½ ββ Ξ½ β§ ΞΌ = ΞΌ.singularPart Ξ½ + Ξ½.withDensity (ΞΌ.rnDeriv Ξ½) := by |
rw [singularPart, rnDeriv, dif_pos h, dif_pos h]
exact Classical.choose_spec h.lebesgue_decomposition
| [
" Measurable (ΞΌ.rnDeriv Ξ½) β§ ΞΌ.singularPart Ξ½ ββ Ξ½ β§ ΞΌ = ΞΌ.singularPart Ξ½ + Ξ½.withDensity (ΞΌ.rnDeriv Ξ½)",
" Measurable (Classical.choose β―).2 β§\n (Classical.choose β―).1 ββ Ξ½ β§ ΞΌ = (Classical.choose β―).1 + Ξ½.withDensity (Classical.choose β―).2"
] | [] |
import Mathlib.Order.BooleanAlgebra
import Mathlib.Tactic.Common
#align_import order.heyting.boundary from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
variable {Ξ± : Type*}
namespace Coheyting
variable [CoheytingAlgebra Ξ±] {a b : Ξ±}
def boundary (a : Ξ±) : Ξ± :=
a β οΏ’a
#align cohe... | Mathlib/Order/Heyting/Boundary.lean | 71 | 72 | theorem boundary_hnot_hnot (a : Ξ±) : β (οΏ’οΏ’a) = β (οΏ’a) := by |
simp_rw [boundary, hnot_hnot_hnot, inf_comm]
| [
" β β€ = β₯",
" β (οΏ’οΏ’a) = β (οΏ’a)"
] | [
" β β€ = β₯"
] |
import Mathlib.RingTheory.GradedAlgebra.HomogeneousIdeal
import Mathlib.Topology.Category.TopCat.Basic
import Mathlib.Topology.Sets.Opens
import Mathlib.Data.Set.Subsingleton
#align_import algebraic_geometry.projective_spectrum.topology from "leanprover-community/mathlib"@"d39590fc8728fbf6743249802486f8c91ffe07bc"
... | Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean | 109 | 111 | theorem mem_vanishingIdeal (t : Set (ProjectiveSpectrum π)) (f : A) :
f β vanishingIdeal t β β x : ProjectiveSpectrum π, x β t β f β x.asHomogeneousIdeal := by |
rw [β SetLike.mem_coe, coe_vanishingIdeal, Set.mem_setOf_eq]
| [
" zeroLocus π β(Ideal.span s) = zeroLocus π s",
" x β zeroLocus π β(Ideal.span s) β x β zeroLocus π s",
" β(vanishingIdeal t) = {f | β x β t, f β x.asHomogeneousIdeal}",
" f β β(vanishingIdeal t) β f β {f | β x β t, f β x.asHomogeneousIdeal}",
" (β (i : ProjectiveSpectrum π), f β (β¨
(_ : i β t), i.asHo... | [
" zeroLocus π β(Ideal.span s) = zeroLocus π s",
" x β zeroLocus π β(Ideal.span s) β x β zeroLocus π s",
" β(vanishingIdeal t) = {f | β x β t, f β x.asHomogeneousIdeal}",
" f β β(vanishingIdeal t) β f β {f | β x β t, f β x.asHomogeneousIdeal}",
" (β (i : ProjectiveSpectrum π), f β (β¨
(_ : i β t), i.asHo... |
import Mathlib.Data.Set.Lattice
#align_import data.set.accumulate from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
variable {Ξ± Ξ² Ξ³ : Type*} {s : Ξ± β Set Ξ²} {t : Ξ± β Set Ξ³}
namespace Set
def Accumulate [LE Ξ±] (s : Ξ± β Set Ξ²) (x : Ξ±) : Set Ξ² :=
β y β€ x, s y
#align set.accumulate S... | Mathlib/Data/Set/Accumulate.lean | 31 | 32 | theorem mem_accumulate [LE Ξ±] {x : Ξ±} {z : Ξ²} : z β Accumulate s x β β y β€ x, z β s y := by |
simp_rw [accumulate_def, mem_iUnionβ, exists_prop]
| [
" z β Accumulate s x β β y β€ x, z β s y"
] | [] |
import Mathlib.Init.Logic
import Mathlib.Init.Function
import Mathlib.Init.Algebra.Classes
import Batteries.Util.LibraryNote
import Batteries.Tactic.Lint.Basic
#align_import logic.basic from "leanprover-community/mathlib"@"3365b20c2ffa7c35e47e5209b89ba9abdddf3ffe"
#align_import init.ite_simp from "leanprover-communit... | Mathlib/Logic/Basic.lean | 1,092 | 1,093 | theorem bex_eq_left {a : Ξ±} : (β (x : _) (_ : x = a), p x) β p a := by |
simp only [exists_prop, exists_eq_left]
| [
" (β x x_1, p x) β p a"
] | [] |
import Mathlib.LinearAlgebra.Dimension.Free
import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
open CategoryTheory
namespace ModuleCat
variable {ΞΉ ΞΉ' R : Type*} [Ring R] {S : ShortComplex (ModuleCat R)}
(hS : S.Exact) (hS' : S.ShortExact) {v : ΞΉ β S.Xβ}
open CategoryTheory Submodule Set
section LinearInde... | Mathlib/Algebra/Category/ModuleCat/Free.lean | 72 | 78 | theorem linearIndependent_shortExact {w : ΞΉ' β S.Xβ} (hw : LinearIndependent R w) :
LinearIndependent R (Sum.elim (S.f β v) (S.g.toFun.invFun β w)) := by |
apply linearIndependent_leftExact hS'.exact hv _ hS'.mono_f rfl
dsimp
convert hw
ext
apply Function.rightInverse_invFun ((epi_iff_surjective _).mp hS'.epi_g)
| [
" Disjoint (span R (range (u β Sum.inl))) (span R (range (u β Sum.inr)))",
" Disjoint (span R (range (u β Sum.inr))) (span R (range (βS.f β v)))",
" Disjoint (span R (range (u β Sum.inr))) (span R (range βS.f))",
" Disjoint (span R (range (u β Sum.inr))) (LinearMap.ker S.g)",
" LinearIndependent R u",
" L... | [
" Disjoint (span R (range (u β Sum.inl))) (span R (range (u β Sum.inr)))",
" Disjoint (span R (range (u β Sum.inr))) (span R (range (βS.f β v)))",
" Disjoint (span R (range (u β Sum.inr))) (span R (range βS.f))",
" Disjoint (span R (range (u β Sum.inr))) (LinearMap.ker S.g)",
" LinearIndependent R u",
" L... |
import Mathlib.Algebra.Field.Defs
import Mathlib.Algebra.GroupWithZero.Units.Lemmas
import Mathlib.Algebra.Ring.Commute
import Mathlib.Algebra.Ring.Invertible
import Mathlib.Order.Synonym
#align_import algebra.field.basic from "leanprover-community/mathlib"@"05101c3df9d9cfe9430edc205860c79b6d660102"
open Function ... | Mathlib/Algebra/Field/Basic.lean | 29 | 29 | theorem add_div (a b c : Ξ±) : (a + b) / c = a / c + b / c := by | simp_rw [div_eq_mul_inv, add_mul]
| [
" (a + b) / c = a / c + b / c"
] | [] |
import Mathlib.MeasureTheory.Measure.MeasureSpace
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
#align_import measure_theory.measure.open_pos from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Topology ENNReal MeasureTheory
open Set Function Filter
namespace Measur... | Mathlib/MeasureTheory/Measure/OpenPos.lean | 107 | 110 | theorem _root_.IsClosed.measure_eq_one_iff_eq_univ [OpensMeasurableSpace X] [IsProbabilityMeasure ΞΌ]
(hF : IsClosed F) :
ΞΌ F = 1 β F = univ := by |
rw [β measure_univ (ΞΌ := ΞΌ), hF.measure_eq_univ_iff_eq]
| [
" ΞΌ U = 0 β U = β
",
" ΞΌ U = 0",
" U =αΆ [ae ΞΌ] β
β U = β
",
" F =αΆ [ae ΞΌ] univ β F = univ",
" F =αΆ [ae ΞΌ] univ",
" F = univ",
" ΞΌ F = ΞΌ univ β F = univ",
" ΞΌ F = 1 β F = univ"
] | [
" ΞΌ U = 0 β U = β
",
" ΞΌ U = 0",
" U =αΆ [ae ΞΌ] β
β U = β
",
" F =αΆ [ae ΞΌ] univ β F = univ",
" F =αΆ [ae ΞΌ] univ",
" F = univ",
" ΞΌ F = ΞΌ univ β F = univ"
] |
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.LinearAlgebra.Matrix.Block
#align_import analysis.inner_product_space.gram_schmidt_ortho from "leanprover-community/mathlib"@"1a4df69ca1a9a0e5e26bfe12e2b92814216016d0"
open Finset Submodule FiniteDimensional
variable (π : Type*) {E : Type*} [RCLike οΏ½... | Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean | 142 | 152 | theorem gramSchmidt_mem_span (f : ΞΉ β E) :
β {j i}, i β€ j β gramSchmidt π f i β span π (f '' Set.Iic j) := by |
intro j i hij
rw [gramSchmidt_def π f i]
simp_rw [orthogonalProjection_singleton]
refine Submodule.sub_mem _ (subset_span (mem_image_of_mem _ hij))
(Submodule.sum_mem _ fun k hk => ?_)
let hkj : k < j := (Finset.mem_Iio.1 hk).trans_le hij
exact smul_mem _ _
(span_mono (image_subset f <| Iic_subset... | [
" (invImage (fun x => x) IsWellOrder.toHasWellFounded).1 (βi) n",
" gramSchmidt π f n = f n - β i β Iio n, β((orthogonalProjection (span π {gramSchmidt π f i})) (f n))",
" f n = gramSchmidt π f n + β i β Iio n, β((orthogonalProjection (span π {gramSchmidt π f i})) (f n))",
" f n = gramSchmidt π f n + β... | [
" (invImage (fun x => x) IsWellOrder.toHasWellFounded).1 (βi) n",
" gramSchmidt π f n = f n - β i β Iio n, β((orthogonalProjection (span π {gramSchmidt π f i})) (f n))",
" f n = gramSchmidt π f n + β i β Iio n, β((orthogonalProjection (span π {gramSchmidt π f i})) (f n))",
" f n = gramSchmidt π f n + β... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.Finsupp.Defs
import Mathlib.Data.Finset.Pairwise
#align_import data.finsupp.big_operators from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
variable {ΞΉ M : Type*} [DecidableEq ΞΉ]
theorem List.support_sum_subset [Add... | Mathlib/Data/Finsupp/BigOperators.lean | 114 | 128 | theorem Finset.support_sum_eq [AddCommMonoid M] (s : Finset (ΞΉ ββ M))
(hs : (s : Set (ΞΉ ββ M)).PairwiseDisjoint Finsupp.support) :
(s.sum id).support = Finset.sup s Finsupp.support := by |
classical
suffices s.1.Pairwise (_root_.Disjoint on Finsupp.support) by
convert Multiset.support_sum_eq s.1 this
exact (Finset.sum_val _).symm
obtain β¨l, hl, hnβ© : β l : List (ΞΉ ββ M), l.toFinset = s β§ l.Nodup := by
refine β¨s.toList, ?_, Finset.nodup_toList _β©
simp
subst hl
rwa [List.toFinset... | [
" l.sum.support β foldr (fun x x_1 => x.support β x_1) β
l",
" [].sum.support β foldr (fun x x_1 => x.support β x_1) β
[]",
" (hd :: tl).sum.support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" (hd + tl.sum).support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" hd.support β hd.support",... | [
" l.sum.support β foldr (fun x x_1 => x.support β x_1) β
l",
" [].sum.support β foldr (fun x x_1 => x.support β x_1) β
[]",
" (hd :: tl).sum.support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" (hd + tl.sum).support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" hd.support β hd.support",... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.