name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Filter.join._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f : Filter (Filter α)), Set.univ ∈ {s | {t | s ∈ t} ∈ f} |
IsCyclotomicExtension.subsingleton_iff._simp_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (S : Set ℕ) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Subsingleton B], IsCyclotomicExtension S A B = (S ⊆ {0, 1}) |
tendsto_comp_coe_Ioo_atTop._simp_1 | Mathlib.Topology.Order.AtTopBotIxx | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X] {a b : X} {α : Type u_2}
{l : Filter α} {f : X → α},
a < b →
autoParam (Order.IsSuccPrelimit b) tendsto_comp_coe_Ioo_atTop._auto_1 →
Filter.Tendsto (fun x => f ↑x) Filter.atTop l = Filter.Tendsto f (nhdsWithin b (Set.Iio b)) l |
CategoryTheory.Limits.ι_colimitFiberwiseColimitIso_inv_assoc | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
(G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H)
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F.map f).toFunctor.comp ((CategoryTheory.Grothendieck.ι F Y).comp G))]
[inst_3 : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.fiberwiseColimit G)]
(X : CategoryTheory.Grothendieck F) {Z : H}
(h : CategoryTheory.Limits.colimit (CategoryTheory.Limits.fiberwiseColimit G) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι G X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitFiberwiseColimitIso G).inv h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι ((CategoryTheory.Grothendieck.ι F X.base).comp G) X.fiber)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι (CategoryTheory.Limits.fiberwiseColimit G) X.base) h) |
Std.PRange.instToStreamRocIterIteratorOfUpwardEnumerable | Init.Data.Range.Polymorphic.Stream | {α : Type u_1} → [Std.PRange.UpwardEnumerable α] → Std.ToStream (Std.Roc α) (Std.Iter α) |
SSet.StrictSegalCore.concat.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet} {n : ℕ} (self self_1 : X.StrictSegalCore n),
self = self_1 →
∀ (x x_1 : X.obj (Opposite.op (SimplexCategory.mk 1))) (e_x : x = x_1)
(s s_1 : X.obj (Opposite.op (SimplexCategory.mk n))) (e_s : s = s_1)
(h :
CategoryTheory.SimplicialObject.δ X 0 x = X.map ((SimplexCategory.mk 0).const (SimplexCategory.mk n) 0).op s),
self.concat x s h = self_1.concat x_1 s_1 ⋯ |
Lean.Elab.Tactic.Do.ProofMode.checkHasType | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Expr → Lean.Expr → optParam Bool false → Lean.MetaM Unit |
extProc._@.Mathlib.Tactic.Attr.Register.612238087._hygCtx._hyg.3 | Mathlib.Tactic.Attr.Register | Lean.Meta.Simp.SimprocExtension |
ContinuousAffineMap.toConstProdContinuousLinearMap._proof_9 | Mathlib.Analysis.Normed.Affine.ContinuousAffineMap | ∀ (𝕜 : Type u_1) (V : Type u_2) (W : Type u_3) [inst : NormedAddCommGroup V] [inst_1 : NormedAddCommGroup W]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 V] [inst_4 : NormedSpace 𝕜 W] (x : V →ᴬ[𝕜] W),
‖{ toFun := fun f => (f 0, f.contLinear), map_add' := ⋯, map_smul' := ⋯,
invFun := fun p => p.2.toContinuousAffineMap + ContinuousAffineMap.const 𝕜 V p.1, left_inv := ⋯,
right_inv := ⋯ }
x‖ =
‖{ toFun := fun f => (f 0, f.contLinear), map_add' := ⋯, map_smul' := ⋯,
invFun := fun p => p.2.toContinuousAffineMap + ContinuousAffineMap.const 𝕜 V p.1, left_inv := ⋯,
right_inv := ⋯ }
x‖ |
HomotopyEquiv.mk._flat_ctor | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
(hom : C ⟶ D) →
(inv : D ⟶ C) →
Homotopy (CategoryTheory.CategoryStruct.comp hom inv) (CategoryTheory.CategoryStruct.id C) →
Homotopy (CategoryTheory.CategoryStruct.comp inv hom) (CategoryTheory.CategoryStruct.id D) →
HomotopyEquiv C D |
MeasureTheory.«_aux_Mathlib_MeasureTheory_VectorMeasure_Basic___macroRules_MeasureTheory_term_⟂ᵥ__1» | Mathlib.MeasureTheory.VectorMeasure.Basic | Lean.Macro |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_eq_sum_segment._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : Finset ι) (f : ι → Set α) (a : α),
(a ∈ ∑ i ∈ t, f i) = ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ t → g i ∈ f i), ∑ i ∈ t, g i = a |
_private.Mathlib.Data.List.Cycle.0.Cycle.Chain._simp_3 | Mathlib.Data.List.Cycle | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) |
Matrix.conjTransposeRingEquiv | Mathlib.LinearAlgebra.Matrix.ConjTranspose | (m : Type u_2) →
(α : Type v) → [inst : Semiring α] → [StarRing α] → [inst_2 : Fintype m] → Matrix m m α ≃+* (Matrix m m α)ᵐᵒᵖ |
QuotientGroup.completeSpace_left | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : Group G] [us : UniformSpace G] [inst_1 : IsLeftUniformGroup G] [FirstCountableTopology G]
(N : Subgroup G) [inst_3 : N.Normal] [hG : CompleteSpace G], CompleteSpace (G ⧸ N) |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_inf | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
Cardinal.lift.{w, v} (A.relrank (B ⊓ f.fieldRange)) |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.lift (CochainComplex.mappingCone.inr φ)
(-(CochainComplex.HomComplex.Cocycle.ofHom φ).leftShift 1 1 ⋯)
(-(CochainComplex.mappingCone.inl φ).leftShift 1 0 ⋯) ⋯)
(CochainComplex.mappingCone.desc (CochainComplex.mappingCone.inr φ) 0 (CochainComplex.mappingCone.triangle φ).mor₃
⋯) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) 1).obj K) |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.CtorHeaderResult.structType | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.CtorHeaderResult✝ → Lean.Expr |
NonarchAddGroupNorm.mk.inj | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} {inst : AddGroup G} {toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0}
{toNonarchAddGroupSeminorm_1 : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero'_1 : ∀ (x : G), toNonarchAddGroupSeminorm_1.toFun x = 0 → x = 0},
{ toNonarchAddGroupSeminorm := toNonarchAddGroupSeminorm, eq_zero_of_map_eq_zero' := eq_zero_of_map_eq_zero' } =
{ toNonarchAddGroupSeminorm := toNonarchAddGroupSeminorm_1,
eq_zero_of_map_eq_zero' := eq_zero_of_map_eq_zero'_1 } →
toNonarchAddGroupSeminorm = toNonarchAddGroupSeminorm_1 |
Lean.Meta.Sym.Simp.EvalStepConfig.noConfusion | Lean.Meta.Sym.Simp.EvalGround | {P : Sort u} →
{t t' : Lean.Meta.Sym.Simp.EvalStepConfig} → t = t' → Lean.Meta.Sym.Simp.EvalStepConfig.noConfusionType P t t' |
PMF.mem_support_iff | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} (p : PMF α) (a : α), a ∈ p.support ↔ p a ≠ 0 |
AugmentedSimplexCategory.instMonoidalCategory._proof_4 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ {X₁ X₂ X₃ Y₁ Y₂ Y₃ : AugmentedSimplexCategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X₁ X₂ X₃).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ (CategoryTheory.MonoidalCategoryStruct.tensorHom f₂ f₃)) |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_10 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (¬x < y) = (y ≤ x) |
Descriptive.Tree.take_mem | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {n : ℕ} (x : ↥T), List.take n ↑x ∈ T |
CategoryTheory.preservesColimits_of_createsColimits_and_hasColimits | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} D],
CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F |
_private.Init.Core.0.decide_true.match_1_1 | Init.Core | ∀ (motive : Decidable True → Prop) (h : Decidable True),
(∀ (h : True), motive (isTrue h)) → (∀ (h : ¬True), motive (isFalse h)) → motive h |
MvPolynomial.IsSymmetric.zero | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R], MvPolynomial.IsSymmetric 0 |
Multiset.countP_attach | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
Multiset.countP (fun a => p ↑a) s.attach = Multiset.countP p s |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable._simp_1_1 | Mathlib.Analysis.Complex.CauchyIntegral | (Real.pi = 0) = False |
Std.HashSet.toList | Std.Data.HashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → Std.HashSet α → List α |
Std.ExtHashMap.mem_insert._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β}, (a ∈ m.insert k v) = ((k == a) = true ∨ a ∈ m) |
Lean.Meta.AC.PreExpr.op.sizeOf_spec | Lean.Meta.Tactic.AC.Main | ∀ (lhs rhs : Lean.Meta.AC.PreExpr), sizeOf (lhs.op rhs) = 1 + sizeOf lhs + sizeOf rhs |
CompHausLike.LocallyConstant.counit._proof_4 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u_1 + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
[inst_3 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
[inst_4 : CompHausLike.HasExplicitFiniteCoproducts P]
(X Y : CategoryTheory.Sheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u_1 u_2))) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u_1 u_2))).obj
(Opposite.op (CompHausLike.of P PUnit.{u_1 + 1}))).comp
(CompHausLike.LocallyConstant.functor P hs)).map
g)
(CategoryTheory.ObjectProperty.homMk (CompHausLike.LocallyConstant.counitApp Y.obj)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ObjectProperty.homMk (CompHausLike.LocallyConstant.counitApp X.obj))
((CategoryTheory.Functor.id
(CategoryTheory.Sheaf (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u_1 u_2)))).map
g) |
unexpandMkArray3 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander |
AlgebraicGeometry.Scheme.jointlySurjectiveTopology | Mathlib.AlgebraicGeometry.Sites.Pretopology | CategoryTheory.GrothendieckTopology AlgebraicGeometry.Scheme |
_private.Lean.Language.Basic.0.Lean.Language.SnapshotTask.ReportingRange.ofOptionInheriting.match_1 | Lean.Language.Basic | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) → ((range : Lean.Syntax.Range) → motive (some range)) → (Unit → motive none) → motive x |
Prod.instReflLex_mathlib_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Refl s], Std.Refl (Prod.Lex r s) |
Finsupp.DegLex.monotone_degree | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], Monotone fun x => Finsupp.degree (ofDegLex x) |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M.addSizeTerm | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M✝ Unit |
Mathlib.Tactic.Monoidal.StructuralOfExpr_monoidalComp | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h i : C} [inst_1 : CategoryTheory.MonoidalCoherence g h]
(η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.monoidalIsoComp η' θ').hom = CategoryTheory.monoidalComp η θ |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.fixingSubgroup_fixedField._simp_1_1 | Mathlib.FieldTheory.Galois.Infinite | ∀ {M : Type u_1} [inst : Mul M] {s : Subsemigroup M} {x : M}, (x ∈ s.carrier) = (x ∈ s) |
Std.Sat.CNF.Clause.relabel_relabel' | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {α_1 : Type u_2} {r1 : α → α_1} {α_2 : Type u_3} {r2 : α_2 → α},
Std.Sat.CNF.Clause.relabel r1 ∘ Std.Sat.CNF.Clause.relabel r2 = Std.Sat.CNF.Clause.relabel (r1 ∘ r2) |
Std.Net.instInhabitedSocketAddress.default | Std.Net.Addr | Std.Net.SocketAddress |
MulMemClass.isRightCancelMul | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : Mul M] [inst_1 : SetLike A M] [hA : MulMemClass A M] [IsRightCancelMul M]
(S : A), IsRightCancelMul ↥S |
Lean.Parser.atomicFn | Lean.Parser.Basic | Lean.Parser.ParserFn → Lean.Parser.ParserFn |
instReprInt | Init.Data.Repr | Repr ℤ |
NonUnitalStarAlgebra.elemental | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | (R : Type u_1) →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : NonUnitalSemiring A] →
[inst_3 : StarRing A] →
[inst_4 : Module R A] →
[IsScalarTower R A A] →
[SMulCommClass R A A] →
[StarModule R A] →
[inst_8 : TopologicalSpace A] →
[IsTopologicalSemiring A] →
[ContinuousConstSMul R A] → [ContinuousStar A] → A → NonUnitalStarSubalgebra R A |
inhomogeneousCochains.d._proof_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Monoid G] (A : Rep k G) (n : ℕ) (r : k) (f : (Fin n → G) → ↑A.V),
(fun g =>
(A.ρ (g 0)) ((r • f) fun i => g i.succ) +
∑ j, (-1) ^ (↑j + 1) • (r • f) (j.contractNth (fun x1 x2 => x1 * x2) g)) =
(RingHom.id k) r • fun g =>
(A.ρ (g 0)) (f fun i => g i.succ) + ∑ j, (-1) ^ (↑j + 1) • f (j.contractNth (fun x1 x2 => x1 * x2) g) |
LinearRecurrence.mkSol._proof_3 | Mathlib.Algebra.LinearRecurrence | ∀ {R : Type u_1} [inst : CommSemiring R] (E : LinearRecurrence R) (a : ℕ) (k : Fin E.order),
a - E.order + ↑k < a → InvImage (fun x1 x2 => x1 < x2) (fun x => x) (a - E.order + ↑k) a |
Submodule.mul_le | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {M N P : Submodule R A}, M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P |
Equiv.pSigmaAssoc._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : α → Sort u_2} (γ : (a : α) → β a → Sort u_3),
Function.RightInverse (fun x => ⟨⟨x.fst, x.snd.fst⟩, x.snd.snd⟩) fun x => ⟨x.fst.fst, ⟨x.fst.snd, x.snd⟩⟩ |
OpenPartialHomeomorph.univUnitBall_apply | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E),
↑OpenPartialHomeomorph.univUnitBall x = (√(1 + ‖x‖ ^ 2))⁻¹ • x |
Int32.toISize_le | Init.Data.SInt.Lemmas | ∀ {a b : Int32}, a.toISize ≤ b.toISize ↔ a ≤ b |
ModuleCat.MonoidalCategory.instBraidedSemimoduleCatFunctorEquivalenceSemimoduleCat | Mathlib.Algebra.Category.ModuleCat.Monoidal.Symmetric | {R : Type u} → [inst : CommRing R] → ModuleCat.equivalenceSemimoduleCat.functor.Braided |
LSeries_one_mul_Lseries_moebius | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {s : ℂ}, 1 < s.re → LSeries 1 s * LSeries (fun n => ↑(ArithmeticFunction.moebius n)) s = 1 |
Std.DTreeMap.Internal.Impl.Const.toListModel_alter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{t : Std.DTreeMap.Internal.Impl α fun x => β} {a : α} {f : Option β → Option β},
t.Balanced →
t.Ordered →
(Std.DTreeMap.Internal.Impl.Const.alter! a f t).toListModel.Perm
(Std.Internal.List.Const.alterKey a f t.toListModel) |
PFun.graph' | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (α →. β) → SetRel α β |
AlgebraicGeometry.Scheme.isoOfEq_inv_ι_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) {U V : X.Opens} (e : U = V) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.isoOfEq e).inv (CategoryTheory.CategoryStruct.comp U.ι h) =
CategoryTheory.CategoryStruct.comp V.ι h |
CategoryTheory.GrpObj.lift_inv_left_eq | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f g h : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp f CategoryTheory.GrpObj.inv)
g)
CategoryTheory.MonObj.mul =
h ↔
g = CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift f h) CategoryTheory.MonObj.mul |
ModuleCat.HasColimit.reflectsColimit | Mathlib.Algebra.Category.ModuleCat.Colimits | ∀ {R : Type w} [inst : Ring R] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat))],
CategoryTheory.Limits.ReflectsColimit F (CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat) |
Std.TreeMap.getElem?_eq_some_getElem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a : α} (h : a ∈ t),
t[a]? = some t[a] |
Nat.compare_eq_ite_lt | Init.Data.Nat.Compare | ∀ (a b : ℕ), compare a b = if a < b then Ordering.lt else if b < a then Ordering.gt else Ordering.eq |
num_smul_one_lt_den_smul_add | Mathlib.Data.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [IsOrderedAddMonoid M] [inst_3 : One M] {u v : ℚ}
{x y : M}, u.num • 1 < u.den • x → v.num • 1 < v.den • y → (u + v).num • 1 < (u + v).den • (x + y) |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.lift_f_snd_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (p q : ℤ), p + 0 = q → q = p |
Aesop.ForwardRuleMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {rule : Aesop.ForwardRule} {«match» : Aesop.CompleteMatch} {rule_1 : Aesop.ForwardRule}
{match_1 : Aesop.CompleteMatch},
{ rule := rule, «match» := «match» } = { rule := rule_1, «match» := match_1 } → rule = rule_1 ∧ «match» = match_1 |
CategoryTheory.Limits.ChosenPullback.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} →
{f₂ : X₂ ⟶ S} →
(pullback : C) →
(p₁ : pullback ⟶ X₁) →
(p₂ : pullback ⟶ X₂) →
(condition : CategoryTheory.CategoryStruct.comp p₁ f₁ = CategoryTheory.CategoryStruct.comp p₂ f₂) →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk p₁ p₂ condition) →
(p : pullback ⟶ S) →
autoParam (CategoryTheory.CategoryStruct.comp p₁ f₁ = p)
CategoryTheory.Limits.ChosenPullback.hp₁._autoParam →
CategoryTheory.Limits.ChosenPullback f₁ f₂ |
List.nodup_permutations_iff | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {s : List α}, s.permutations.Nodup ↔ s.Nodup |
Plausible.TotalFunction.zeroDefault.eq_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type u} {β : Type v} [inst : Zero β] (A : List ((_ : α) × β)) (a : β),
(Plausible.TotalFunction.withDefault A a).zeroDefault = Plausible.TotalFunction.withDefault A 0 |
Associates.one_or_eq_of_le_of_prime | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {p m : Associates M}, Prime p → m ≤ p → m = 1 ∨ m = p |
Set.infsep_of_fintype._proof_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], s.Nontrivial → s.offDiag.toFinset.Nonempty |
partialOrderOfSO.match_5 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) (x : α) (motive : (y : α) → x = y ∨ r x y → y = x ∨ r y x → Prop) (y : α)
(h₁ : x = y ∨ r x y) (h₂ : y = x ∨ r y x),
(∀ (x_1 : x = x ∨ r x x), motive x ⋯ x_1) →
(∀ (x_1 : x = x ∨ r x x), motive x x_1 ⋯) →
(∀ (x_1 : α) (h₁ : r x x_1) (h₂ : r x_1 x), motive x_1 ⋯ ⋯) → motive y h₁ h₂ |
Set.Finite.inter_of_left | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∀ (t : Set α), (s ∩ t).Finite |
RingOfIntegers.exponent_eq_one_iff | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K},
RingOfIntegers.exponent θ = 1 ↔ Algebra.adjoin ℤ {θ} = ⊤ |
GradedTensorProduct.instRing._proof_17 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ]
(a : GradedTensorProduct R 𝒜 ℬ), -a + a = 0 |
_private.Mathlib.Topology.Instances.Matrix.0.Matrix.GeneralLinearGroup.continuous_upperRightHom._simp_1_5 | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} [inst : TopologicalSpace X], (Continuous fun x => x) = True |
Lean.Meta.Grind.Arith.CommRing.MonadRing.recOn | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadRing | {m : Type → Type} →
{motive : Lean.Meta.Grind.Arith.CommRing.MonadRing m → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.MonadRing m) →
((getRing : m Lean.Meta.Grind.Arith.CommRing.Ring) →
(modifyRing : (Lean.Meta.Grind.Arith.CommRing.Ring → Lean.Meta.Grind.Arith.CommRing.Ring) → m Unit) →
motive { getRing := getRing, modifyRing := modifyRing }) →
motive t |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_7 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
CauSeq.IsComplete.isComplete | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} {inst : Field α} {inst_1 : LinearOrder α} {inst_2 : IsStrictOrderedRing α} {β : Type u_2}
{inst_3 : Ring β} {abv : β → α} {inst_4 : IsAbsoluteValue abv} [self : CauSeq.IsComplete β abv] (s : CauSeq β abv),
∃ b, s ≈ CauSeq.const abv b |
SeparationQuotient.exists_out_continuousLinearMap | Mathlib.Topology.Algebra.SeparationQuotient.Section | ∀ (K : Type u_1) (E : Type u_2) [inst : DivisionRing K] [inst_1 : AddCommGroup E] [inst_2 : Module K E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : ContinuousConstSMul K E],
∃ f, (SeparationQuotient.mkCLM K E).comp f = ContinuousLinearMap.id K (SeparationQuotient E) |
CategoryTheory.CoreSmallCategoryOfSet.functor | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) → CategoryTheory.Functor (↑h.smallCategoryOfSet.obj) C |
BoundedLatticeHom.dual._proof_4 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom αᵒᵈ βᵒᵈ), f.toFun ⊤ = ⊤ |
CategoryTheory.Comonad.Coalgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Comonad C → Type (max u₁ v₁) |
CategoryTheory.PreOneHypercover.IsStronglySheafFor.map_amalgamate | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {E : CategoryTheory.PreOneHypercover X}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (h : E.IsStronglySheafFor F)
(x : (i : E.I₀) → F.obj (Opposite.op (E.X i)))
(hc : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), F.map (E.p₁ k).op (x i) = F.map (E.p₂ k).op (x j)) (i : E.I₀),
F.map (E.f i).op (h.amalgamate x hc) = x i |
Std.HashMap.erase_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ},
(Std.HashMap.emptyWithCapacity c).erase a = Std.HashMap.emptyWithCapacity c |
_private.Mathlib.Dynamics.Ergodic.Extreme.0.Ergodic.of_mem_extremePoints._simp_1_1 | Mathlib.Dynamics.Ergodic.Extreme | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.IsProbabilityMeasure μ = (μ Set.univ = 1) |
PseudoMetric.IsUltra.sup | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : AddZeroClass R] [inst_1 : SemilatticeSup R] [inst_2 : AddLeftMono R]
[inst_3 : AddRightMono R] {d d' : PseudoMetric X R} [d.IsUltra] [d'.IsUltra], (d ⊔ d').IsUltra |
CategoryTheory.NatTrans.instCommShiftOppositeShiftHomFunctorNatIsoComp | Mathlib.CategoryTheory.Shift.Opposite | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
{E : Type u_4} [inst_5 : CategoryTheory.Category.{v_3, u_4} E] [inst_6 : CategoryTheory.HasShift E A]
(G : CategoryTheory.Functor D E) [inst_7 : F.CommShift A] [inst_8 : G.CommShift A],
CategoryTheory.NatTrans.CommShift (CategoryTheory.NatTrans.OppositeShift.natIsoComp A F G).hom A |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.IsCompact.nhdsSet_basis_isCompact._proof_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {K : Set X} ⦃s t : Set X⦄,
s ⊆ t → (∃ r ∈ nhdsSet K, IsCompact r ∧ r ⊆ s) → ∃ r ∈ nhdsSet K, IsCompact r ∧ r ⊆ t |
Std.MaxEqOr.max_eq_or | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Max α} [self : Std.MaxEqOr α] (a b : α), a ⊔ b = a ∨ a ⊔ b = b |
Lean.Widget.instToJsonRpcEncodablePacket._@.Lean.Widget.InteractiveGoal.1056429149._hygCtx._hyg.45 | Lean.Widget.InteractiveGoal | Lean.ToJson Lean.Widget.RpcEncodablePacket✝ |
IntermediateField.coe_algebraMap_over_bot | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
⇑(algebraMap (↥⊥) F) = ⇑(IntermediateField.botEquiv F E) |
CategoryTheory.Limits.prod.symmetry' | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : C) [inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q]
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst)
(CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst) =
CategoryTheory.CategoryStruct.id (P ⨯ Q) |
Matrix.empty_vecAlt1 | Mathlib.Data.Fin.VecNotation | ∀ (α : Type u_1) {h : 0 = 0 + 0}, Matrix.vecAlt1 h ![] = ![] |
_private.Std.Sat.AIG.RefVecOperator.Fold.0.Std.Sat.AIG.RefVec.denote_fold_and._proof_1_1 | Std.Sat.AIG.RefVecOperator.Fold | ∀ {len : ℕ}, ¬0 ≤ len → False |
CategoryTheory.NatTrans.leftOp._proof_1 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C Dᵒᵖ} (α : F ⟶ G) (X Y : Cᵒᵖ)
(f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp (G.leftOp.map f) (α.app (Opposite.unop Y)).unop).op =
(CategoryTheory.CategoryStruct.comp (α.app (Opposite.unop X)).unop (F.leftOp.map f)).op |
IsUnit.isUnit_iff_mulLeft_bijective | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a : M}, IsUnit a ↔ Function.Bijective fun x => a * x |
_private.Mathlib.Analysis.ODE.PicardLindelof.0.ContDiffAt.exists_eventually_eq_hasDerivAt._proof_1_1 | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E], ContinuousSMul ℝ E |
UniformSpace.Completion.ring._proof_30 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsUniformAddGroup α], ↑0 = 0 |
TopologicalSpace.Opens.comap._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β))
(x x_1 : TopologicalSpace.Opens β),
{ carrier := ⇑f ⁻¹' ↑(x ⊓ x_1), is_open' := ⋯ } = { carrier := ⇑f ⁻¹' ↑(x ⊓ x_1), is_open' := ⋯ } |
Matrix.normedSpace | Mathlib.Analysis.Matrix.Normed | {R : Type u_1} →
{m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} →
[inst : Fintype m] →
[inst_1 : Fintype n] →
[inst_2 : NormedField R] →
[inst_3 : SeminormedAddCommGroup α] → [NormedSpace R α] → NormedSpace R (Matrix m n α) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.