name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.ProofWidgets.Data.Html.0.ProofWidgets.Jsx.transformTag.match_10 | ProofWidgets.Data.Html | (motive : Lean.Ident × Lean.Term → Sort u_1) →
(x : Lean.Ident × Lean.Term) → ((k : Lean.Ident) → (v : Lean.Term) → motive (k, v)) → motive x | null | false |
ProofWidgets.RefreshComponent.RpcEncodablePacket.mk._flat_ctor._@.ProofWidgets.Component.RefreshComponent.311896448._hygCtx._hyg.1 | ProofWidgets.Component.RefreshComponent | Lean.Json → Lean.Json → ProofWidgets.RefreshComponent.RpcEncodablePacket✝ | null | false |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.range_natCast._simp_1_4 | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, (c < Cardinal.aleph0) = ∃ n, c = ↑n | null | false |
CategoryTheory.Prod.braiding | Mathlib.CategoryTheory.Products.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → C × D ≌ D × C | The equivalence, given by swapping factors, between `C × D` and `D × C`.
| true |
LinearMap.lift_rank_le_of_surjective | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Function.Surjective ⇑f → Cardinal.lift.{v, v'} (Module.rank R M') ≤ Cardinal.lift.{v', v} (Module.rank R M) | null | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
Function.Injective (Quotient.lift (NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K) ⋯) ∧
Function.Surjective (Quotient.lift (NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K) ⋯) | null | false |
fwdDiff_aux.fwdDiffₗ_apply | Mathlib.Algebra.Group.ForwardDiff | ∀ (M : Type u_1) (G : Type u_2) [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (f : M → G) (a : M),
(fwdDiff_aux.fwdDiffₗ M G h) f a = fwdDiff h f a | null | true |
SSet.Subcomplex.existsN | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | ∀ {X : SSet} {n : ℕ} (s : X.obj (Opposite.op { len := n })) {A : X.Subcomplex},
s ∉ A.obj (Opposite.op { len := n }) →
∃ x f, CategoryTheory.Epi f ∧ (CategoryTheory.ConcreteCategory.hom (X.map f.op)) x.simplex = s | null | true |
_private.Mathlib.Data.Finset.Lattice.Fold.0.Finset.lt_sup_iff.match_1_5 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_1} [inst : LinearOrder α] {s : Finset ι} {f : ι → α} {a : α}
(motive : (∃ b ∈ s, a < f b) → Prop) (x : ∃ b ∈ s, a < f b),
(∀ (b : ι) (hb : b ∈ s) (hlt : a < f b), motive ⋯) → motive x | null | false |
Lean.Elab.ConfigEval.EvalConfigItem.mk.injEq | Lean.Elab.ConfigEval.Types | ∀ {α : Type} (set set_1 : α → Lean.Elab.ConfigEval.ConfigItem → Lean.Elab.TermElabM α),
({ set := set } = { set := set_1 }) = (set = set_1) | null | true |
_private.Mathlib.Topology.ContinuousOn.0.continuous_prod_of_discrete_left._simp_1_1 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
Continuous f = ContinuousOn f Set.univ | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.FiniteExtension.0.Module.Basis.norm_nonneg._simp_1_5 | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∃ x, b) = b | null | false |
CommMonCat.limitCommMonoid._aux_4 | Mathlib.Algebra.Category.MonCat.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J CommMonCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommMonCat)).sections] →
CommMonoid ↑(F.comp (CategoryTheory.forget CommMonCat)).sections →
(CategoryTheory.Limits... | null | false |
ENat.lt_top_of_sum_ne_top | Mathlib.Data.ENat.BigOperators | ∀ {α : Type u_1} {s : Finset α} {f : α → ℕ∞}, ∑ x ∈ s, f x ≠ ⊤ → ∀ {a : α}, a ∈ s → f a < ⊤ | null | true |
UnitalShelf.act_self_act_eq | Mathlib.Algebra.Quandle | ∀ {S : Type u_1} [inst : UnitalShelf S] (x y : S), Shelf.act x (Shelf.act x y) = Shelf.act x y | null | true |
Multiset.toFinsupp._proof_2 | Mathlib.Data.Finsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α),
(fun f => Finsupp.toMultiset f)
((fun s => { support := s.toFinset, toFun := fun a => Multiset.count a s, mem_support_toFun := ⋯ }) s) =
s | null | false |
CategoryTheory.Pretriangulated.Opposite.instHasShiftOppositeInt._proof_11 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ],
autoParam
(∀ (X : CategoryTheory.Discrete ℤ),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
((CategoryTheory.Pretriangulated.Opposite.instHasShiftOppositeInt._aux_1 C).obj X)).hom =
... | null | false |
isSimplyConnected_smul_set₀_iff._simp_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {G : Type u_3} [inst_1 : GroupWithZero G] [inst_2 : MulAction G X]
[ContinuousConstSMul G X] {c : G} {s : Set X}, c ≠ 0 → IsSimplyConnected (c • s) = IsSimplyConnected s | null | false |
IsDedekindDomain.HeightOneSpectrum.instCoeIdeal | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {R : Type u_1} → [inst : CommRing R] → Coe (IsDedekindDomain.HeightOneSpectrum R) (Ideal R) | null | true |
_private.Mathlib.MeasureTheory.SpecificCodomains.WithLp.0.MeasureTheory.memLp_piLp_iff._simp_1_1 | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p : ENNReal} {ι : Type u_2} [inst : Fintype ι]
{E : ι → Type u_3} [inst_1 : (i : ι) → NormedAddCommGroup (E i)] {f : X → (i : ι) → E i},
(∀ (i : ι), MeasureTheory.MemLp (fun x => f x i) p μ) = MeasureTheory.MemLp f p μ | null | false |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.Polynomial.coe_injective._simp_1_1 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] (φ : Polynomial R) (n : ℕ), φ.coeff n = (PowerSeries.coeff n) ↑φ | null | false |
IsCornerFree.eq_1 | Mathlib.Combinatorics.Additive.Corner.Roth | ∀ {G : Type u_1} [inst : AddCommMonoid G] (A : Set (G × G)),
IsCornerFree A = ∀ ⦃x₁ y₁ x₂ y₂ : G⦄, IsCorner A x₁ y₁ x₂ y₂ → x₁ = x₂ | null | true |
SemiNormedGrp₁.of | Mathlib.Analysis.Normed.Group.SemiNormedGrp | (carrier : Type u) → [str : SeminormedAddCommGroup carrier] → SemiNormedGrp₁ | Construct a bundled `SemiNormedGrp₁` from the underlying type and typeclass. | true |
MvPowerSeries.map._proof_7 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S)
(φ ψ : MvPowerSeries σ R),
(fun n => f ((MvPowerSeries.coeff n) (φ + ψ))) =
(fun n => f ((MvPowerSeries.coeff n) φ)) + fun n => f ((MvPowerSeries.coeff n) ψ) | null | false |
QuadraticAlgebra.mk_mul_mk | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : Mul R] [inst_1 : Add R] (x1 y1 x2 y2 : R),
{ re := x1, im := y1 } * { re := x2, im := y2 } =
{ re := x1 * x2 + a * y1 * y2, im := x1 * y2 + y1 * x2 + b * y1 * y2 } | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.param_eq._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {α : Type u_4} (s : Set α) [inst : Fintype ↑s], Fintype.card ↑s = s.toFinset.card | null | false |
CompositionAsSet.card_boundaries_pos | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), 0 < c.boundaries.card | null | true |
Int.sub_mul_bmod_self_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ) (c : ℕ), (a - b * ↑c).bmod c = a.bmod c | null | true |
Mathlib.Tactic.ITauto.Proof.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} → {t t' : Mathlib.Tactic.ITauto.Proof} → t = t' → Mathlib.Tactic.ITauto.Proof.noConfusionType P t t' | null | false |
Lean.Elab.evalSyntaxConstant | Lean.Elab.Util | Lean.Environment → Lean.Options → Lean.Name → ExceptT String Id Lean.Syntax | null | true |
Polynomial.roots_C_mul | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} {a : R} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
a ≠ 0 → (Polynomial.C a * p).roots = p.roots | null | true |
SMulWithZero.compHom | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{M₀' : Type u_3} →
(A : Type u_7) →
[inst : Zero M₀] →
[inst_1 : Zero A] → [SMulWithZero M₀ A] → [inst_3 : Zero M₀'] → ZeroHom M₀' M₀ → SMulWithZero M₀' A | Compose a `SMulWithZero` with a `ZeroHom`, with action `f r' • m` | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.expOpenPartialHomeomorph._simp_3 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
Std.Internal.Do.WPMonad.tryCatch_StateT_lift_wp | Std.Internal.Do.WP.Lemmas | ∀ {Pred : Type u_1} {EPred : Type u_2} {ε : Type u_3} {m : Type u → Type v} [inst : Monad m]
[inst_1 : Std.Internal.Do.Assertion Pred] [inst_2 : Std.Internal.Do.Assertion EPred]
[inst_3 : Std.Internal.Do.WPMonad m Pred EPred] [inst_4 : MonadExceptOf ε m] {σ α : Type u} {post : α → σ → Pred}
{epost : EPred} (x : S... | null | true |
Con.instCompleteLattice._proof_2 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] (s : Set (Con M)), sInf s ∈ lowerBounds s ∧ sInf s ∈ upperBounds (lowerBounds s) | null | false |
NumberField.InfinitePlace.liesOver_conjugate_embedding_of_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {w : NumberField.InfinitePlace L},
w ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v →
NumberField.ComplexEmbedding.LiesOver (NumberField.ComplexEmbedding.conjugate w.embedding) v.embe... | null | true |
Subgroup.instEncodableSubtypeMulOppositeMemOp.eq_1 | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : Group G] (H : Subgroup G) [inst_1 : Encodable ↥H],
H.instEncodableSubtypeMulOppositeMemOp = Encodable.ofEquiv (↥H) H.equivOp.symm | null | true |
CategoryTheory.StrictPseudofunctor.comp_obj | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C] {D : Type u₃}
[inst_2 : CategoryTheory.Bicategory D] (F : CategoryTheory.StrictPseudofunctor B C)
(G : CategoryTheory.StrictPseudofunctor C D) (X : B), (F.comp G).obj X = G.obj (F.obj X) | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofZeros_H | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0),
(CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg).H = S.X₂ | null | true |
IsCoprime.of_mul_left_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime (x * y) z → IsCoprime x z | null | true |
IsTopologicalAddGroup.toHSpace._proof_5 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : AddZeroClass M] [inst_1 : TopologicalSpace M] [inst_2 : ContinuousAdd M],
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousMap.const M 0).prodMk (ContinuousMap.id M)) =
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousM... | null | false |
Submodule.IsMinimalPrimaryDecomposition.comap_localized₀_eq_ite | Mathlib.RingTheory.Lasker | ∀ {R : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
(s₀ : Finset ↑N.associatedPrimes),
IsLowerSet ↑s₀ →
∀ (q : Submodule R M),
q.IsPrimary →
∀ (p : ↑N.associatedPrimes),
(q.colon Set.univ).radical = ↑p →
Sub... | null | true |
Std.DHashMap.Internal.Raw.size_eq_length | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.Raw.WFImp m → m.size = (Std.DHashMap.Internal.toListModel m.buckets).length | null | true |
Lean.Grind.GrobnerConfig.qlia._inherited_default | Init.Grind.Config | Bool | null | false |
Finmap.keys_singleton | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (a : α) (b : β a), (Finmap.singleton a b).keys = {a} | null | true |
Std.TreeMap.mk.injEq | Std.Data.TreeMap.Basic | ∀ {α : Type u} {β : Type v} {cmp : autoParam (α → α → Ordering) Std.TreeMap._auto_1}
(inner inner_1 : Std.DTreeMap α (fun x => β) cmp), ({ inner := inner } = { inner := inner_1 }) = (inner = inner_1) | null | true |
Representation.TensorProduct.comm_symm | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W),
(Representation.TensorProduct.comm σ ρ).symm = Represen... | null | true |
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.circleIntegral.circleIntegral_congr_codiscreteWithin._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
CategoryTheory.Functor.leftKanExtensionIsoFiberwiseColimit_hom_app | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] [inst_4 : L.Has... | null | true |
OrderIso.prodComm | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : LE α] → [inst_1 : LE β] → α × β ≃o β × α | `Prod.swap` as an `OrderIso`. | true |
OpenPartialHomeomorph.extend_preimage_mem_nhdsWithin | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {s t : Set M} {x : M},
x ∈ f.sour... | Technical lemma ensuring that the preimage under an extended chart of a neighborhood of a point
in the source is a neighborhood of the preimage, within a set. | true |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.WithBot.instArchimedean._simp_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {α : Type u} [inst : AddMonoid α] (a : α) (n : ℕ), n • ↑a = ↑(n • a) | null | false |
floorDiv_one | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : MulActionWithZero α β] [inst_5 : FloorDiv α β] [IsOrderedRing α] [Nontrivial α]
(b : β), b ⌊/⌋ 1 = b | null | true |
RBTree.RBNode.upperBound?_ge | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cut : α → Ordering} {x : α} {t : RBTree.RBNode α},
RBTree.RBNode.upperBound? cut t = some x → cut x ≠ Ordering.gt | The value `x` returned by `upperBound?` is greater or equal to the `cut`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.IsBipartiteWith.edgeSetEmbeddingCompleteBipartiteGraph._proof_37 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {s t : Set V} [inst : DecidableRel fun x1 x2 => x1 ∈ x2]
(hG : G.IsBipartiteWith s t) (x : ↑G.edgeSet) (x x_1 : V)
(a : Quot.mk (Sym2.Rel V) (x, x_1) ∈ (SimpleGraph.edgeSetEmbedding V) G)
(a' : Quot.mk (Sym2.Rel V) (x_1, x) ∈ (SimpleGraph.edgeSetEmbedding V) G),
⋯ ≍ ⋯ →
... | null | false |
Algebra.TensorProduct.mapOfCompatibleSMul._proof_7 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_4) (S : Type u_1) (T : Type u_5) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : CommSemiring T] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] [inst_7 : Algebra S A] [inst_8 : Algebra S B] [inst_9 : Algebra T A]
[i... | null | false |
CategoryTheory.MonoidalCategory.selRightfAction._proof_11 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {d d' : C}
(f : d ⟶ d'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor d).hom f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.wh... | null | false |
Nat._aux_Mathlib_Algebra_Order_Floor_Defs___unexpand_Nat_floor_1 | Mathlib.Algebra.Order.Floor.Defs | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Topology.Instances.Real.Lemmas.0.closure_ordConnected_inter_rat._simp_1_5 | Mathlib.Topology.Instances.Real.Lemmas | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, (a - b < c) = (a - c < b) | null | false |
LinearIsometry.map_sub | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) (x y : E), f (x - y) = f x - f y | null | true |
TwoSidedIdeal.rightModule | Mathlib.RingTheory.TwoSidedIdeal.Operations | {R : Type u_1} → [inst : Ring R] → (I : TwoSidedIdeal R) → Module Rᵐᵒᵖ ↥I | null | true |
IntermediateField.sInf_toSubalgebra | 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]
(S : Set (IntermediateField F E)), (sInf S).toSubalgebra = sInf (IntermediateField.toSubalgebra '' S) | null | true |
Lean.Grind.Linarith.zero_ne_one_of_charC_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (c : ℕ) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.zero_ne_one_of_charC_cert c p =
(decide (↑c > 1) && p == Lean.Grind.Linarith.Poly.add 1 0 Lean.Grind.Linarith.Poly.nil) | null | true |
Fintype.linearCombination._proof_3 | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_2} {M : Type u_1} (R : Type u_3) [inst : Fintype α] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (v : α → M) (f g : α → R), ∑ i, (f + g) i • v i = ∑ i, f i • v i + ∑ i, g i • v i | null | false |
Homeomorph.toOpenPartialHomeomorphOfImageEq._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y) (s : Set X)
(t : Set Y) (h : ⇑e '' s = t), ContinuousOn (⇑e) (e.toPartialEquivOfImageEq s t h).source | null | false |
CochainComplex.HomComplex.Cochain.shift_units_smul | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type u_1}
[inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] {K L : CochainComplex C ℤ} {n : ℤ}
(γ : CochainComplex.HomComplex.Cochain K L n) (a : ℤ) (x : Rˣ), (x • γ).shift a = x • γ.shift a | null | true |
DistribSMul.mk.noConfusion | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_12} →
{A : Type u_13} →
{inst : AddZeroClass A} →
{P : Sort u} →
{toSMulZeroClass : SMulZeroClass M A} →
{smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y} →
{toSMulZeroClass' : SMulZeroClass M A} →
{smul_add' : ∀ (a : M) (x y : A), a • (x +... | null | false |
List.take_take | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i j : ℕ} {l : List α}, List.take i (List.take j l) = List.take (min i j) l | null | true |
DifferentiableWithinAt.clm_comp | Mathlib.Analysis.Calculus.FDeriv.CompCLM | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {s : Set E} {H : Type u_5}
... | null | true |
Nat.ModEq.listProd_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {n : ℕ} {l : List ℕ}, (∀ x ∈ l, x ≡ 1 [MOD n]) → l.prod ≡ 1 [MOD n] | null | true |
Projectivization.independent_iff_iSupIndep | Mathlib.LinearAlgebra.Projectivization.Independence | ∀ {ι : Type u_1} {K : Type u_2} {V : Type u_3} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{f : ι → Projectivization K V}, Projectivization.Independent f ↔ iSupIndep fun i => (f i).submodule | A family of points in projective space is independent if and only if the family of
submodules which the points determine is independent in the lattice-theoretic sense. | true |
eq_true_of_ne_false | Init.Prelude | ∀ {b : Bool}, ¬b = false → b = true | null | true |
DoubleCentralizer.nnnorm_def' | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (a : DoubleCentralizer 𝕜 A),
‖a‖₊ = ‖DoubleCentralizer.toProdMulOppositeHom a‖₊ | null | true |
_private.Mathlib.Data.Nat.Hyperoperation.0.hyperoperation_ge_two_eq_self._proof_1_2 | Mathlib.Data.Nat.Hyperoperation | ∀ (m n : ℕ), hyperoperation (n + 2) m 1 = m → hyperoperation (n + 1 + 2) m 1 = m | null | false |
norm_eq_zero._simp_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedAddGroup E] {a : E}, (‖a‖ = 0) = (a = 0) | null | false |
_private.Lean.Meta.Tactic.Grind.Inv.0.Lean.Meta.Grind.checkChild | Lean.Meta.Tactic.Grind.Inv | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
MvPolynomial.rTensorAlgEquiv.eq_1 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u} {N : Type v} [inst : CommSemiring R] {σ : Type u_1} {S : Type u_3} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : CommSemiring N] [inst_4 : Algebra R N] [inst_5 : DecidableEq σ],
MvPolynomial.rTensorAlgEquiv = AlgEquiv.ofLinearEquiv MvPolynomial.rTensor ⋯ ⋯ | null | true |
Matrix.reindexLinearEquiv_mul | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {m' : Type u_6} {n' : Type u_7} {o' : Type u_8} (R : Type u_11)
(A : Type u_12) [inst : Semiring R] [inst_1 : Semiring A] [inst_2 : Module R A] [inst_3 : Fintype n]
[inst_4 : Fintype n'] (eₘ : m ≃ m') (eₙ : n ≃ n') (eₒ : o ≃ o') (M : Matrix m n A) (N : Matrix n o A),
... | null | true |
ContinuousAlternatingMap.instTopologicalSpace | Mathlib.Topology.Algebra.Module.Alternating.Topology | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
{ι : Type u_4} →
[inst : NormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : AddCommGroup F] →
[inst_5 : Module 𝕜 F]... | null | true |
Std.HashMap.Raw.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α Unit} [EquivBEq α] [LawfulHashable α],
m.WF →
∀ {l : List α} {k k' fallback : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKeyD k' fallback = k | null | true |
LinearMap.IsPosSemidef.add | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I₁ : R →+* R}
[inst_3 : Preorder R] [AddLeftMono R] {B C : M →ₛₗ[I₁] M →ₗ[R] R},
B.IsPosSemidef → C.IsPosSemidef → (B + C).IsPosSemidef | null | true |
LeanSearchClient.unicode_turnstile | LeanSearchClient.LoogleSyntax | Lean.Parser.Parser | null | true |
DomMulAct.instMulDistribMulActionMonoidHom._proof_2 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {A : Type u_2} {M : Type u_1} {B : Type u_3} [inst : Monoid M] [inst_1 : Monoid A] [inst_2 : MulDistribMulAction M A]
[inst_3 : CommMonoid B] (x : Mᵈᵐᵃ) (x_1 : A →* B), (MonoidHom.coeFn A B) (x • x_1) = (MonoidHom.coeFn A B) (x • x_1) | null | false |
Disjoint.of_preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β},
Function.Surjective f → ∀ {s t : Set β}, Disjoint (f ⁻¹' s) (f ⁻¹' t) → Disjoint s t | null | true |
CommRingCat.coyonedaUnique_inv_app_hom_apply | Mathlib.Algebra.Category.Ring.Adjunctions | ∀ {n : Type v} [inst : Unique n] (X : CommRingCat) (a : ↑X) (a_1 : Opposite.unop (Opposite.op n)),
(CommRingCat.Hom.hom (CommRingCat.coyonedaUnique.inv.app X)) a a_1 = a | null | true |
Int.emod_eq_zero_of_dvd | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ}, a ∣ b → b % a = 0 | null | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary.eq_def | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (iM : Q(CommGroupWithZero «$M»))
(_x : (_ : Mathlib.Tactic.FieldSimp.qNF M) ×' Mathlib.Tactic.FieldSimp.qNF M),
Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary iM _x =
PSigma.casesOn _x fun l₁ l₂ =>
match l₁, l₂ with
| [], l =>
have a := l.toNF;
q(⋯)... | null | false |
CategoryTheory.Oplax.LaxTrans.Hom.as | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} → CategoryTheory.Oplax.LaxTrans.Hom η θ → CategoryTheory.Oplax.LaxTrans.Modification η θ | The underlying modification of lax transformations. | true |
Lean.Meta.SynthInstance.TableEntry.mk.injEq | Lean.Meta.SynthInstance | ∀ (waiters : Array Lean.Meta.SynthInstance.Waiter) (answers : Array Lean.Meta.SynthInstance.Answer)
(waiters_1 : Array Lean.Meta.SynthInstance.Waiter) (answers_1 : Array Lean.Meta.SynthInstance.Answer),
({ waiters := waiters, answers := answers } = { waiters := waiters_1, answers := answers_1 }) =
(waiters = wa... | null | true |
FirstOrder.Language.BoundedFormula.realize_iAlls._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} [inst_1 : Finite β]
{φ : L.Formula (α ⊕ β)} {v : α → M} {v' : Fin 0 → M},
FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Formula.iAlls β φ) v v' =
∀ (i : β → M), φ.Realize fun a => Sum.elim v i a | null | false |
CategoryTheory.Limits.FintypeCat.inclusion_preservesFiniteColimits | Mathlib.CategoryTheory.Limits.FintypeCat | CategoryTheory.Limits.PreservesFiniteColimits FintypeCat.incl | null | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.digitsAux0.match_1.eq_1 | Mathlib.Data.Nat.Digits.Defs | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
SemimoduleCat.coe_of | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ (R : Type u) [inst : Semiring R] (X : Type v) [inst_1 : Semiring X] [inst_2 : Module R X], ↑(SemimoduleCat.of R X) = X | null | true |
Std.TreeMap.Raw.getElem!_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {k a : α} {v : β}, (t.insert k v)[a]! = if cmp k a = Ordering.eq then v else t[a]! | null | true |
MeasureTheory.integrableOn_iff_comap_subtypeVal | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasurableSet s →
(MeasureTheory.IntegrableOn f s μ ↔
MeasureTheory.Integrable (f ∘ Subtype.val) (MeasureTheory.Measure.comap Subtype.val... | null | true |
instCommRingBDeRhamPlus._proof_12 | Mathlib.RingTheory.Perfectoid.BDeRham | ∀ (R : Type u_1) [inst : CommRing R] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
[inst_3 : IsAdicComplete (Ideal.span {↑p}) R] (a b : BDeRhamPlus R p), a + b = b + a | null | false |
LieIdeal.mem_rootSet | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] {I : LieIdeal K L}
{α : ↥LieSubalgebra.root}, α ∈ I.rootSet ↔ LieAlgebra.rootSpace H ⇑↑α ≤ LieSubmodule.restr I H | null | true |
Localization.lt._proof_2 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelMonoid α] {s : Submonoid α} {a₁ b₁ : α}
{a₂ b₂ : ↥s} {c₁ d₁ : α} {c₂ d₂ : ↥s},
(Localization.r s) (a₁, a₂) (b₁, b₂) →
(Localization.r s) (c₁, c₂) (d₁, d₂) → (↑c₂ * a₁ < ↑a₂ * c₁) = (↑d₂ * b₁ < ↑b₂ * d₁) | null | false |
vsub_left_injective | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] (p : P), Function.Injective fun x => x -ᵥ p | Subtracting the point `p` is an injective function. | true |
CategoryTheory.Subfunctor.IsFinite.x._proof_1 | Mathlib.CategoryTheory.Subfunctor.Finite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{G : CategoryTheory.Subfunctor F} [hG : G.IsFinite], ∃ x, Nonempty (G.IsGeneratedBy x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.