name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preregular C] →
[inst_2 : CategoryTheory.FinitaryExtensive C] →
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))} →
(∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.map (CategoryTheory.homOfLE ⋯).op)) →
(X : C) →
(F.obj (Opposite.op 0)).obj.obj (Opposite.op X) →
(n : ℕ) → (Y : C) × (F.obj (Opposite.op n)).obj.obj (Opposite.op Y) |
Nat.ofDigits_lt_base_pow_length' | Mathlib.Data.Nat.Digits.Defs | ∀ {b : ℕ} {l : List ℕ}, (∀ x ∈ l, x < b + 2) → Nat.ofDigits (b + 2) l < (b + 2) ^ l.length |
String.Pos.next.eq_1 | Init.Data.String.Basic | ∀ {s : String} (pos : s.Pos) (h : pos ≠ s.endPos), pos.next h = String.Pos.ofToSlice (pos.toSlice.next ⋯) |
Std.Internal.List.getValueCast!_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {f : (a : α) → β a → Bool}
{l : List ((a : α) × β a)} {k : α} [inst_2 : Inhabited (β k)],
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCast! k (List.filter (fun p => f p.fst p.snd) l) =
(Option.filter (f k) (Std.Internal.List.getValueCast? k l)).get! |
_private.Mathlib.Topology.Homeomorph.Defs.0.Homeomorph.isInducing._simp_1_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X], Topology.IsInducing id = True |
Lean.Server.RequestHandlerCompleteness.rec | Lean.Server.Requests | {motive : Lean.Server.RequestHandlerCompleteness → Sort u} →
motive Lean.Server.RequestHandlerCompleteness.complete →
((refreshMethod : String) →
(refreshIntervalMs : ℕ) →
motive (Lean.Server.RequestHandlerCompleteness.partial refreshMethod refreshIntervalMs)) →
(t : Lean.Server.RequestHandlerCompleteness) → motive t |
CategoryTheory.PreGaloisCategory.IsFundamentalGroup.rec | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
[inst_1 : CategoryTheory.GaloisCategory C] →
{G : Type u_1} →
[inst_2 : Group G] →
[inst_3 : (X : C) → MulAction G (F.obj X).obj] →
[inst_4 : TopologicalSpace G] →
[inst_5 : IsTopologicalGroup G] →
[inst_6 : CompactSpace G] →
{motive : CategoryTheory.PreGaloisCategory.IsFundamentalGroup F G → Sort u} →
([toIsNaturalSMul : CategoryTheory.PreGaloisCategory.IsNaturalSMul F G] →
(transitive_of_isGalois :
∀ (X : C) [CategoryTheory.PreGaloisCategory.IsGalois X],
MulAction.IsPretransitive G (F.obj X).obj) →
(continuous_smul : ∀ (X : C), ContinuousSMul G (F.obj X).obj) →
(non_trivial' : ∀ (g : G), (∀ (X : C) (x : (F.obj X).obj), g • x = x) → g = 1) →
motive ⋯) →
(t : CategoryTheory.PreGaloisCategory.IsFundamentalGroup F G) → motive t |
Lean.LBool.false.elim | Lean.Data.LBool | {motive : Lean.LBool → Sort u} → (t : Lean.LBool) → t.ctorIdx = 0 → motive Lean.LBool.false → motive t |
TopologicalSpace.Opens.mapId._proof_3 | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat),
CategoryTheory.CategoryStruct.comp { app := fun U => CategoryTheory.eqToHom ⋯, naturality := ⋯ }
{ app := fun U => CategoryTheory.eqToHom ⋯, naturality := ⋯ } =
CategoryTheory.CategoryStruct.id (TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)) |
WeierstrassCurve.Affine.CoordinateRing.quotientXYIdealEquiv._proof_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} {x : R} {y : Polynomial R},
(Ideal.map (Ideal.Quotient.mkₐ R (Ideal.span {W'.polynomial}))
(Ideal.span {Polynomial.C (Polynomial.X - Polynomial.C x), Polynomial.X - Polynomial.C y})).IsTwoSided |
midpoint_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : Invertible 2] (x y : E), midpoint 𝕜 x y ∈ segment 𝕜 x y |
CategoryTheory.Monad.Algebra.Hom.mk.congr_simp | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra}
(f f_1 : A.A ⟶ B.A) (e_f : f = f_1)
(h : CategoryTheory.CategoryStruct.comp (T.map f) B.a = CategoryTheory.CategoryStruct.comp A.a f),
{ f := f, h := h } = { f := f_1, h := ⋯ } |
_private.Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition.0.Submodule.rank_le_one_iff_isPrincipal._simp_1_1 | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V], (Module.rank K V ≤ 1) = ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v |
upperBounds_prod | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → upperBounds (s ×ˢ t) = upperBounds s ×ˢ upperBounds t |
Algebra.Generators.Hom.mk.sizeOf_spec | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra S S']
[inst_7 : SizeOf R] [inst_8 : SizeOf S] [inst_9 : SizeOf ι] [inst_10 : SizeOf R'] [inst_11 : SizeOf S']
[inst_12 : SizeOf ι'] (val : ι → P'.Ring)
(aeval_val : ∀ (i : ι), (MvPolynomial.aeval P'.val) (val i) = (algebraMap S S') (P.val i)),
sizeOf { val := val, aeval_val := aeval_val } = 1 |
Lean.Meta.Grind.Filter.fvar | Lean.Meta.Tactic.Grind.Filter | Lean.FVarId → Lean.Meta.Grind.Filter |
_private.Lean.Compiler.LCNF.Visibility.0.Lean.Compiler.LCNF.markDeclPublicRec.match_1 | Lean.Compiler.LCNF.Visibility | (phase : Lean.Compiler.LCNF.Phase) →
(motive : Option (Lean.Compiler.LCNF.Decl phase.toPurity) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl phase.toPurity)) →
((refDecl : Lean.Compiler.LCNF.Decl phase.toPurity) → motive (some refDecl)) →
((x : Option (Lean.Compiler.LCNF.Decl phase.toPurity)) → motive x) → motive __do_lift |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.subst.match_3 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((val : Lean.Expr × Lean.Expr × Lean.Expr) → motive (some val)) → (Unit → motive none) → motive __do_lift |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {motive : Fin (n + 1) → Sort u_1} {succ : (i : Fin n) → motive i.succ → motive i.castSucc} (i : Fin n) (j : ℕ)
(h : j < n + 1) (h2 : ↑i < j) (zero : motive ⟨j, h⟩),
Fin.reverseInduction.go succ i.castSucc j h ⋯ zero = succ i (Fin.reverseInduction.go succ i.succ j h h2 zero) |
RootPairing.smul_coroot_eq_of_root_eq_smul | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} [Finite ι]
[IsAddTorsionFree N] (i j : ι) (t : R), P.root j = t • P.root i → t • P.coroot j = P.coroot i |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.insert._sparseCasesOn_7 | Lean.Meta.Tactic.Grind.Theorems | {motive : Lean.HeadIndex → Sort u} →
(t : Lean.HeadIndex) →
((constName : Lean.Name) → motive (Lean.HeadIndex.const constName)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
Finset.mem_powersetCard._simp_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, (s ∈ Finset.powersetCard n t) = (s ⊆ t ∧ s.card = n) |
BoxIntegral.Prepartition.instOrderTop | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} → {I : BoxIntegral.Box ι} → OrderTop (BoxIntegral.Prepartition I) |
CategoryTheory.LocalizerMorphism.arrow | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
CategoryTheory.LocalizerMorphism W₁ W₂ → CategoryTheory.LocalizerMorphism W₁.arrow W₂.arrow |
Lean.Lsp.instToJsonRange | Lean.Data.Lsp.BasicAux | Lean.ToJson Lean.Lsp.Range |
Units.instMulDistribMulAction._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {M : Type u_1} {α : Type u_2} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction M α] (m : Mˣ),
↑m • 1 = 1 |
Affine.Simplex.faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] →
[inst_3 : AddTorsor V P] →
{n : ℕ} → [NeZero n] → Affine.Simplex k P n → Fin (n + 1) → Affine.Simplex k P (n - 1) |
UniformSpace.hausdorff._proof_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ (α : Type u_1) [inst : UniformSpace α],
Filter.Tendsto Prod.swap ((uniformity α).lift' hausdorffEntourage) ((uniformity α).lift' hausdorffEntourage) |
DirectSum.decomposeAlgEquiv_apply | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [inst_5 : GradedAlgebra 𝒜] (a : A),
(DirectSum.decomposeAlgEquiv 𝒜) a = (DirectSum.decompose 𝒜) a |
CategoryTheory.δ_naturality_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) {m n : M}
{X Y : C} (f : X ⟶ Y) [inst_3 : F.OplaxMonoidal] {Z : C} (h : (F.obj n).obj ((F.obj m).obj Y) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.OplaxMonoidal.δ F m n).app X)
(CategoryTheory.CategoryStruct.comp ((F.obj n).map ((F.obj m).map f)) h) =
CategoryTheory.CategoryStruct.comp ((F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj m n)).map f)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.OplaxMonoidal.δ F m n).app Y) h) |
symmDiff_symmDiff_cancel_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] (a b : α), symmDiff a (symmDiff a b) = b |
PMF.binomial_apply_zero | Mathlib.Probability.ProbabilityMassFunction.Binomial | ∀ (p : NNReal) (h : p ≤ 1) (n : ℕ), (PMF.binomial p h n) 0 = (1 - ↑p) ^ n |
Ne.dite_ne_right_iff | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {P : Prop} [inst : Decidable P] {b : α} {A : P → α},
(∀ (h : P), A h ≠ b) → ((dite P A fun x => b) ≠ b ↔ P) |
Std.HashMap.size_insertIfNew | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, (m.insertIfNew k v).size = if k ∈ m then m.size else m.size + 1 |
CategoryTheory.EnrichedCat.bicategory._proof_14 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c d : CategoryTheory.EnrichedCat V} {f f' : CategoryTheory.EnrichedFunctor V ↑a ↑b} (η : f ⟶ f')
(g : CategoryTheory.EnrichedFunctor V ↑b ↑c) (h : CategoryTheory.EnrichedFunctor V ↑c ↑d),
CategoryTheory.EnrichedCat.whiskerRight η (CategoryTheory.EnrichedFunctor.comp V g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.EnrichedCat.associator f g h).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.EnrichedCat.whiskerRight (CategoryTheory.EnrichedCat.whiskerRight η g) h)
(CategoryTheory.EnrichedCat.associator f' g h).hom) |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_11 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ), 0 < table.size → table.size - 1 < table.size |
SSet.horn₃₁.desc | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | {X : SSet} →
(f₀ f₂ f₃ : SSet.stdSimplex.obj (SimplexCategory.mk 2) ⟶ X) →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₀ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₃ →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) f₀ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₂ →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₂ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₃ →
((SSet.horn 3 1).toSSet ⟶ X) |
BoundedContinuousFunction._aux_Mathlib_Topology_ContinuousMap_Bounded_Basic___unexpand_BoundedContinuousFunction_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | Lean.PrettyPrinter.Unexpander |
IsHomeomorph.surjective | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsHomeomorph f → Function.Surjective f |
_private.Batteries.Data.List.Basic.0.List.dropSlice_zero₂.match_1_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : ℕ → List α → Prop) (x : ℕ) (x_1 : List α),
(∀ (a : Unit), motive 0 []) →
(∀ (head : α) (tail : List α), motive 0 (head :: tail)) →
(∀ (n : ℕ), motive n.succ []) → (∀ (n : ℕ) (x : α) (xs : List α), motive n.succ (x :: xs)) → motive x x_1 |
CategoryTheory.Iso.inv_ext' | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : Y ⟶ X},
CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.id X → g = f.inv |
List.Vector.«_aux_Mathlib_Data_Vector_Basic___macroRules_List_Vector_term_::ᵥ__1» | Mathlib.Data.Vector.Basic | Lean.Macro |
ContinuousOn.image_Icc_of_antitoneOn | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[OrderTopology α] [inst_3 : TopologicalSpace β] [DenselyOrdered α] [inst_5 : ConditionallyCompleteLinearOrder β]
[OrderTopology β] {f : α → β} {a b : α},
a ≤ b → ContinuousOn f (Set.Icc a b) → AntitoneOn f (Set.Icc a b) → f '' Set.Icc a b = Set.Icc (f b) (f a) |
LieAlgebra.IsExtension.casesOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{L : Type u_3} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : LieRing N] →
[inst_4 : LieAlgebra R N] →
[inst_5 : LieRing M] →
[inst_6 : LieAlgebra R M] →
{i : N →ₗ⁅R⁆ L} →
{p : L →ₗ⁅R⁆ M} →
{motive : LieAlgebra.IsExtension i p → Sort u} →
(t : LieAlgebra.IsExtension i p) →
((ker_eq_bot : i.ker = ⊥) →
(range_eq_top : p.range = ⊤) →
(exact : i.range = LieIdeal.toLieSubalgebra R L p.ker) → motive ⋯) →
motive t |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.renameFunAuxImage.match_1 | Mathlib.RingTheory.MvPowerSeries.Rename | {σ : Type u_2} →
{τ : Type u_1} →
(motive : ((τ →₀ ℕ) × (τ →₀ ℕ)) × (σ →₀ ℕ) × (σ →₀ ℕ) → Sort u_3) →
(x : ((τ →₀ ℕ) × (τ →₀ ℕ)) × (σ →₀ ℕ) × (σ →₀ ℕ)) →
((fst : (τ →₀ ℕ) × (τ →₀ ℕ)) → (b : (σ →₀ ℕ) × (σ →₀ ℕ)) → motive (fst, b)) → motive x |
Polynomial.reflect.match_1 | Mathlib.Algebra.Polynomial.Reverse | {R : Type u_1} →
[inst : Semiring R] →
(motive : Polynomial R → Sort u_2) →
(x : Polynomial R) → ((f : AddMonoidAlgebra R ℕ) → motive { toFinsupp := f }) → motive x |
cfcHom_predicate | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R A p] {a : A} (ha : p a)
(f : C(↑(spectrum R a), R)), p ((cfcHom ha) f) |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.inner_eq_norm_mul_norm_mul_cos_oangle._simp_1_7 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False |
_private.Init.Data.List.ToArray.0.List.findSomeRevM?_find_toArray | Init.Data.List.ToArray | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] (f : α → m (Option β))
(l : List α) (i : ℕ) (h : i ≤ l.toArray.size),
Array.findSomeRevM?.find✝ f l.toArray i h = List.findSomeM? f (List.take i l).reverse |
ContinuousLinearEquiv.submoduleMap._proof_2 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid M₂] [inst_5 : TopologicalSpace M₂]
{module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁}
{re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (e : M ≃SL[σ₁₂] M₂) (p : Submodule R M),
Continuous ⇑(((↑e).comp p.subtypeL).codRestrict (Submodule.map (↑e.toLinearEquiv) p) ⋯) |
apply_dite | Init.ByCases | ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [inst : Decidable P] (x : P → α) (y : ¬P → α),
f (dite P x y) = if h : P then f (x h) else f (y h) |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_105 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Matrix.mul_one | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix m n α), M * 1 = M |
Std.IterM.TerminationMeasures.Productive.casesOn | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{motive : Std.IterM.TerminationMeasures.Productive α m → Sort u} →
(t : Std.IterM.TerminationMeasures.Productive α m) → ((it : Std.IterM m β) → motive { it := it }) → motive t |
ContDiffMapSupportedIn.zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Set.EqOn (⇑f) 0 (↑K)ᶜ |
Set.image2_inter_union_subset | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {f : α → α → β} {s t : Set α},
(∀ (a b : α), f a b = f b a) → Set.image2 f (s ∩ t) (s ∪ t) ⊆ Set.image2 f s t |
Set.Icc_add_Ico_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Icc a b + Set.Ico c d ⊆ Set.Ico (a + c) (b + d) |
Lean.Grind.Linarith.instBEqPoly.beq._sunfold | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool |
WithAbs.instRing._proof_3 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Ring R] (v : AbsoluteValue R S),
autoParam (∀ (n : ℕ) (a : WithAbs v), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam |
Con.monoid._proof_4 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Monoid M] (c : Con M) (a : c.Quotient), 1 * a = a |
TopologicalSpace.le_generateFrom_iff_subset_isOpen | Mathlib.Topology.Order | ∀ {α : Type u} {g : Set (Set α)} {t : TopologicalSpace α}, t ≤ TopologicalSpace.generateFrom g ↔ g ⊆ {s | IsOpen s} |
DomMulAct.instDistribMulActionSubtypeAEEqFunMemAddSubgroupLp | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | {M : Type u_1} →
{α : Type u_3} →
{E : Type u_4} →
[inst : MeasurableSpace α] →
[inst_1 : NormedAddCommGroup E] →
{μ : MeasureTheory.Measure α} →
{p : ENNReal} →
[inst_2 : Monoid M] →
[inst_3 : MulAction M α] →
[MeasureTheory.SMulInvariantMeasure M α μ] →
[MeasurableConstSMul M α] → DistribMulAction Mᵈᵐᵃ ↥(MeasureTheory.Lp E p μ) |
Fin.castSucc_pos | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {i : Fin n}, 0 < i → 0 < i.castSucc |
Std.PRange.UpwardEnumerable.least | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u_1} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.Least? α] → [Std.PRange.LawfulUpwardEnumerableLeast? α] → [hn : Nonempty α] → α |
CategoryTheory.Limits.IsLimit.assoc._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y}
{sYZ : CategoryTheory.Limits.BinaryFan Y Z} (P : CategoryTheory.Limits.IsLimit sXY)
(Q : CategoryTheory.Limits.IsLimit sYZ) {s : CategoryTheory.Limits.BinaryFan sXY.pt Z}
(R : CategoryTheory.Limits.IsLimit s) (t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X sYZ.pt))
(j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp (R.lift (CategoryTheory.Limits.BinaryFan.assocInv P t))
((CategoryTheory.Limits.BinaryFan.assoc Q s).π.app j) =
t.π.app j |
Sym.map_mk._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_2} {β : Type u_1} {n : ℕ} {f : α → β} {m : Multiset α} {hc : m.card = n}, (Multiset.map f m).card = n |
Function.HasTemperateGrowth.toTemperedDistribution._proof_6 | Mathlib.Analysis.Distribution.TemperedDistribution | RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) |
Mathlib.Tactic.Linarith.applyContrLemma | Mathlib.Tactic.Linarith.Frontend | Lean.MVarId → Lean.MetaM (Option (Lean.Expr × Lean.Expr) × Lean.MVarId) |
Pi.spectrum_eq | Mathlib.Algebra.Algebra.Spectrum.Pi | ∀ {ι : Type u_1} {R : Type u_4} {κ : ι → Type u_5} [inst : CommSemiring R] [inst_1 : (i : ι) → Ring (κ i)]
[inst_2 : (i : ι) → Algebra R (κ i)] (a : (i : ι) → κ i), spectrum R a = ⋃ i, spectrum R (a i) |
Path.Homotopic.Quotient.symm | Mathlib.Topology.Homotopy.Path | {X : Type u} → [inst : TopologicalSpace X] → {x₀ x₁ : X} → Path.Homotopic.Quotient x₀ x₁ → Path.Homotopic.Quotient x₁ x₀ |
CategoryTheory.Limits.FormalCoproduct.powerMap_id | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Limits.FormalCoproduct C) (α : Type t)
[inst_1 : CategoryTheory.Limits.HasProductsOfShape α C],
CategoryTheory.Limits.FormalCoproduct.powerMap (CategoryTheory.CategoryStruct.id U) α =
CategoryTheory.CategoryStruct.id (U.power α) |
Lean.«binderPred⊃_» | Init.BinderPredicates | Lean.ParserDescr |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingsForName.match_4 | Lean.Parser.Term.Doc | (motive : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling) → Sort u_1) →
(x : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling)) →
((strs : Array Lean.Parser.Term.Doc.RecommendedSpelling) → motive (some strs)) →
((x : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling)) → motive x) → motive x |
CategoryTheory.InjectiveResolution.isoRightDerivedObj_hom_naturality_assoc | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X)
(J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex),
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (φ.f 0) = CategoryTheory.CategoryStruct.comp f (J.ι.f 0) →
∀ (F : CategoryTheory.Functor C D) [inst_5 : F.Additive] (n : ℕ) {Z : D}
(h :
(HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) n).obj
((F.mapHomologicalComplex (ComplexShape.up ℕ)).obj J.cocomplex) ⟶
Z),
CategoryTheory.CategoryStruct.comp ((F.rightDerived n).map f)
(CategoryTheory.CategoryStruct.comp (J.isoRightDerivedObj F n).hom h) =
CategoryTheory.CategoryStruct.comp (I.isoRightDerivedObj F n).hom
(CategoryTheory.CategoryStruct.comp
((HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) n).map
((F.mapHomologicalComplex (ComplexShape.up ℕ)).map φ))
h) |
Lean.Elab.Term.CollectPatternVars.Context.casesOn | Lean.Elab.PatternVar | {motive : Lean.Elab.Term.CollectPatternVars.Context → Sort u} →
(t : Lean.Elab.Term.CollectPatternVars.Context) →
((funId : Lean.Ident) →
(ctorVal? : Option Lean.ConstructorVal) →
(explicit ellipsis : Bool) →
(paramDecls : Array (Lean.Name × Lean.BinderInfo)) →
(paramDeclIdx : ℕ) →
(namedArgs : Array Lean.Elab.Term.NamedArg) →
(usedNames : Std.HashSet Lean.Name) →
(args : List Lean.Elab.Term.Arg) →
(newArgs : Array Lean.Term) →
motive
{ funId := funId, ctorVal? := ctorVal?, explicit := explicit, ellipsis := ellipsis,
paramDecls := paramDecls, paramDeclIdx := paramDeclIdx, namedArgs := namedArgs,
usedNames := usedNames, args := args, newArgs := newArgs }) →
motive t |
Lean.Lsp.InitializeParams.processId?._default | Lean.Data.Lsp.InitShutdown | Option ℤ |
MonoidAlgebra.ext | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] ⦃f g : MonoidAlgebra R M⦄, (∀ (m : M), f m = g m) → f = g |
ContinuousMultilinearMap.opNorm_prod | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[inst_6 : NormedSpace 𝕜 G'] [inst_7 : Fintype ι] (f : ContinuousMultilinearMap 𝕜 E G)
(g : ContinuousMultilinearMap 𝕜 E G'), ‖f.prod g‖ = max ‖f‖ ‖g‖ |
Std.Rci.mk.inj | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {lower lower_1 : α}, lower...* = lower_1...* → lower = lower_1 |
ContinuousAlgEquiv.isUniformEmbedding | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} [inst : CommSemiring R] {E₁ : Type u_5} {E₂ : Type u_6} [inst_1 : UniformSpace E₁]
[inst_2 : UniformSpace E₂] [inst_3 : Ring E₁] [IsUniformAddGroup E₁] [inst_5 : Algebra R E₁] [inst_6 : Ring E₂]
[IsUniformAddGroup E₂] [inst_8 : Algebra R E₂] (e : E₁ ≃A[R] E₂), IsUniformEmbedding ⇑e |
RootedTree.mk.injEq | Mathlib.Order.SuccPred.Tree | ∀ (α : Type u_2) [semilatticeInf : SemilatticeInf α] [orderBot : OrderBot α] [predOrder : PredOrder α]
[isPredArchimedean : IsPredArchimedean α] (α_1 : Type u_2) (semilatticeInf_1 : SemilatticeInf α_1)
(orderBot_1 : OrderBot α_1) (predOrder_1 : PredOrder α_1) (isPredArchimedean_1 : IsPredArchimedean α_1),
({ α := α, semilatticeInf := semilatticeInf, orderBot := orderBot, predOrder := predOrder,
isPredArchimedean := isPredArchimedean } =
{ α := α_1, semilatticeInf := semilatticeInf_1, orderBot := orderBot_1, predOrder := predOrder_1,
isPredArchimedean := isPredArchimedean_1 }) =
(α = α_1 ∧ semilatticeInf ≍ semilatticeInf_1 ∧ orderBot ≍ orderBot_1 ∧ predOrder ≍ predOrder_1) |
_private.Lean.Meta.Check.0.Lean.Meta.addPPExplicitToExposeDiff.visit.match_13 | Lean.Meta.Check | (motive : MProd Lean.Expr (MProd Lean.Expr (MProd (Option ℕ) (Option ℕ))) → Sort u_1) →
(x : MProd Lean.Expr (MProd Lean.Expr (MProd (Option ℕ) (Option ℕ)))) →
((aFnType bFnType : Lean.Expr) →
(firstExplicitDiff? firstImplicitDiff? : Option ℕ) →
motive ⟨aFnType, bFnType, firstExplicitDiff?, firstImplicitDiff?⟩) →
motive x |
Lean.Kernel.Exception.unknownConstant.inj | Lean.Environment | ∀ {env : Lean.Kernel.Environment} {name : Lean.Name} {env_1 : Lean.Kernel.Environment} {name_1 : Lean.Name},
Lean.Kernel.Exception.unknownConstant env name = Lean.Kernel.Exception.unknownConstant env_1 name_1 →
env = env_1 ∧ name = name_1 |
Primrec.cond | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Bool} {f g : α → σ},
Primrec c → Primrec f → Primrec g → Primrec fun a => bif c a then f a else g a |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.logMap_expMapBasis._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ |
nat_abs_sum_le | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} (s : Finset ι) (f : ι → ℤ), (∑ i ∈ s, f i).natAbs ≤ ∑ i ∈ s, (f i).natAbs |
CovariantDerivative.finite_affine_combination._proof_2 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {M : Type u_3} {V : M → Type u_2}
[inst_1 : (x : M) → AddCommGroup (V x)] [inst_2 : (x : M) → Module 𝕜 (V x)]
[inst_3 : (x : M) → TopologicalSpace (V x)] [∀ (x : M), ContinuousSMul 𝕜 (V x)] (x : M), ContinuousConstSMul 𝕜 (V x) |
OnePoint.continuousMapMkDiscrete._proof_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : TopologicalSpace Y] [inst_2 : DiscreteTopology X]
(f : X → Y) (y : Y),
Filter.Tendsto f Filter.cofinite (nhds y) →
Filter.Tendsto (⇑{ toFun := f, continuous_toFun := ⋯ }) (Filter.coclosedCompact X) (nhds y) |
Subsemiring.toIsStrictOrderedRing | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (s : Subsemiring R),
IsStrictOrderedRing ↥s |
String.Pos.Raw.isValidForSlice_eq_false_iff._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
(String.Pos.Raw.isValidForSlice s p = false) = ¬String.Pos.Raw.IsValidForSlice s p |
Std.TreeMap.getKeyD_maxKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.maxKey! fallback = t.maxKey! |
CartanMatrix.Generators.F.sizeOf_spec | Mathlib.Algebra.Lie.SerreConstruction | ∀ {B : Type v} [inst : SizeOf B] (a : B), sizeOf (CartanMatrix.Generators.F a) = 1 + sizeOf a |
IterateAddAct.instMeasurableSpace.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Instances | ∀ {α : Type u_1} {f : α → α}, IterateAddAct.instMeasurableSpace = ⊤ |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.DihedralGroup.center_eq_bot_of_odd_ne_one._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ}, Odd n → n ≠ 1 → 1 < n |
CategoryTheory.InjectiveResolution.add_extMk | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y) {n : ℕ}
(f g : X ⟶ R.cocomplex.X n) (m : ℕ) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruct.comp f (R.cocomplex.d n m) = 0)
(hg : CategoryTheory.CategoryStruct.comp g (R.cocomplex.d n m) = 0),
R.extMk f m hm hf + R.extMk g m hm hg = R.extMk (f + g) m hm ⋯ |
DiffeologicalSpace.CorePlotsOn.mk.inj | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1}
{isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop}
{isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotOn hu q)}
{isPlot : {n : ℕ} → (EuclideanSpace ℝ (Fin n) → X) → Prop}
{isPlotOn_univ :
autoParam (∀ {n : ℕ} {p : EuclideanSpace ℝ (Fin n) → X}, isPlotOn ⋯ p ↔ isPlot p)
DiffeologicalSpace.CorePlotsOn.isPlotOn_univ._autoParam}
{isPlot_const : ∀ {n : ℕ} (x : X), isPlot fun x_1 => x}
{isPlotOn_reparam :
∀ {n m : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} {v : Set (EuclideanSpace ℝ (Fin m))} {hu : IsOpen u}
(hv : IsOpen v) {p : EuclideanSpace ℝ (Fin n) → X} {f : EuclideanSpace ℝ (Fin m) → EuclideanSpace ℝ (Fin n)},
Set.MapsTo f v u → isPlotOn hu p → ContDiffOn ℝ (↑⊤) f v → isPlotOn hv (p ∘ f)}
{locality :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p : EuclideanSpace ℝ (Fin n) → X},
(∀ x ∈ u, ∃ v, ∃ (hv : IsOpen v), x ∈ v ∧ isPlotOn hv p) → isPlotOn hu p}
{dTopology : TopologicalSpace X}
{isOpen_iff_preimages_plots :
autoParam
(∀ {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ} (p : EuclideanSpace ℝ (Fin n) → X), isPlot p → IsOpen (p ⁻¹' u))
DiffeologicalSpace.CorePlotsOn.isOpen_iff_preimages_plots._autoParam}
{isPlotOn_1 : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop}
{isPlotOn_congr_1 :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn_1 hu p ↔ isPlotOn_1 hu q)}
{isPlot_1 : {n : ℕ} → (EuclideanSpace ℝ (Fin n) → X) → Prop}
{isPlotOn_univ_1 :
autoParam (∀ {n : ℕ} {p : EuclideanSpace ℝ (Fin n) → X}, isPlotOn_1 ⋯ p ↔ isPlot_1 p)
DiffeologicalSpace.CorePlotsOn.isPlotOn_univ._autoParam}
{isPlot_const_1 : ∀ {n : ℕ} (x : X), isPlot_1 fun x_1 => x}
{isPlotOn_reparam_1 :
∀ {n m : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} {v : Set (EuclideanSpace ℝ (Fin m))} {hu : IsOpen u}
(hv : IsOpen v) {p : EuclideanSpace ℝ (Fin n) → X} {f : EuclideanSpace ℝ (Fin m) → EuclideanSpace ℝ (Fin n)},
Set.MapsTo f v u → isPlotOn_1 hu p → ContDiffOn ℝ (↑⊤) f v → isPlotOn_1 hv (p ∘ f)}
{locality_1 :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p : EuclideanSpace ℝ (Fin n) → X},
(∀ x ∈ u, ∃ v, ∃ (hv : IsOpen v), x ∈ v ∧ isPlotOn_1 hv p) → isPlotOn_1 hu p}
{dTopology_1 : TopologicalSpace X}
{isOpen_iff_preimages_plots_1 :
autoParam
(∀ {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ} (p : EuclideanSpace ℝ (Fin n) → X), isPlot_1 p → IsOpen (p ⁻¹' u))
DiffeologicalSpace.CorePlotsOn.isOpen_iff_preimages_plots._autoParam},
{ isPlotOn := isPlotOn, isPlotOn_congr := isPlotOn_congr, isPlot := isPlot, isPlotOn_univ := isPlotOn_univ,
isPlot_const := isPlot_const, isPlotOn_reparam := isPlotOn_reparam, locality := locality,
dTopology := dTopology, isOpen_iff_preimages_plots := isOpen_iff_preimages_plots } =
{ isPlotOn := isPlotOn_1, isPlotOn_congr := isPlotOn_congr_1, isPlot := isPlot_1,
isPlotOn_univ := isPlotOn_univ_1, isPlot_const := isPlot_const_1, isPlotOn_reparam := isPlotOn_reparam_1,
locality := locality_1, dTopology := dTopology_1, isOpen_iff_preimages_plots := isOpen_iff_preimages_plots_1 } →
isPlotOn = isPlotOn_1 ∧ isPlot = isPlot_1 ∧ dTopology = dTopology_1 |
Std.Roo.HasRcoIntersection.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type w} → Std.Roo.HasRcoIntersection α → ℕ |
Batteries.Random.MersenneTwister.State.twist | Batteries.Data.Random.MersenneTwister | {cfg : Batteries.Random.MersenneTwister.Config} →
Batteries.Random.MersenneTwister.State cfg → Batteries.Random.MersenneTwister.State cfg |
NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal._proof_8 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ContinuousAdd ℝ |
Eq.ndrec_symm.congr_simp | Init.Grind.Ring.CommSolver | ∀ {α : Sort u2} {a : α} {motive : α → Sort u1} (m m_1 : motive a),
m = m_1 → ∀ {b : α} (h : b = a), Eq.ndrec_symm m h = Eq.ndrec_symm m_1 h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.