name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubgroup.neg._proof_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) (a : ↥H), -↑a ∈ H | null | false |
Lean.Elab.Term.BinderView.rec | Lean.Elab.Binders | {motive : Lean.Elab.Term.BinderView → Sort u} →
((ref id type : Lean.Syntax) → (bi : Lean.BinderInfo) → motive { ref := ref, id := id, type := type, bi := bi }) →
(t : Lean.Elab.Term.BinderView) → motive t | null | false |
CompactlyCoherentSpace.of_isOpen | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {X : Type u} [inst : TopologicalSpace X],
(∀ (A : Set X), (∀ (K : Set X), IsCompact K → IsOpen (Subtype.val ⁻¹' A)) → IsOpen A) → CompactlyCoherentSpace X | If every set `A` is open if for every compact `K` the intersection `K ∩ A` is open in `K`,
then the space is a compactly coherent space. | true |
addCommutator_eq_bot_iff_center_eq_top | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G], addCommutator G = ⊥ ↔ AddSubgroup.center G = ⊤ | null | true |
contMDiffOn_extend_symm | Mathlib.Geometry.Manifold.ContMDiff.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : WithTop ℕ∞} {e : OpenPartialHomeom... | null | true |
RingHom.FormallyUnramified.of_comp | Mathlib.RingTheory.RingHom.Unramified | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {T : Type u_3} [inst_2 : CommRing T]
{f : R →+* S} {g : S →+* T}, (g.comp f).FormallyUnramified → g.FormallyUnramified | null | true |
TopModuleCat.toCoinduced._proof_4 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {M : ModuleCat R} {I : Type u_3} {X : I → TopModuleCat R}
(f : (i : I) → (X i).toModuleCat ⟶ M) (i : I), Continuous (ModuleCat.Hom.hom (f i)).toFun | null | false |
DirectSum.sum_support_decompose | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike σ M]
[inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ]
[inst_5 : (i : ι) → (x : ↥(ℳ i)) → Decidable (x ≠ 0)] (r : M),
∑ i ∈ DFinsupp.support ((DirectSum.decompose ℳ) r... | null | true |
ProbabilityTheory.Kernel.iIndepSets.indepSets | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {s : ι → Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α},
ProbabilityTheory.Kernel.iIndepSets s κ μ → ∀ {i j : ι}, i ≠ j → ProbabilityTheory.Kernel.IndepSets (s i) (s j) κ μ | null | true |
Bimod.AssociatorBimod.homAux._proof_4 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X... | null | false |
MeasurableSpace.comap_mono | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {m₁ m₂ : MeasurableSpace α} {g : β → α},
m₁ ≤ m₂ → MeasurableSpace.comap g m₁ ≤ MeasurableSpace.comap g m₂ | null | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.Context.mk | Lean.Compiler.LCNF.ExplicitRC | Lean.FVarIdHashSet →
Lean.Compiler.LCNF.DerivedValMap✝ →
Lean.Compiler.LCNF.VarMap✝ → Lean.Compiler.LCNF.JPLiveVarMap✝ → ℕ → Lean.Compiler.LCNF.Context✝ | null | true |
Qq.«termQl(_)» | Qq.Macro | Lean.ParserDescr | `ql(u)` quotes the universe level `u`. | true |
_private.Mathlib.Analysis.Oscillation.0.IsCompact.uniform_oscillationWithin._simp_1_9 | Mathlib.Analysis.Oscillation | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
MonoidAlgebra.mapDomainRingEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | (R : Type u_3) →
{M : Type u_6} →
{N : Type u_7} →
[inst : Semiring R] → [inst_1 : Monoid M] → [inst_2 : Monoid N] → M ≃* N → MonoidAlgebra R M ≃+* MonoidAlgebra R N | Isomorphic monoids have isomorphic monoid algebras. | true |
_private.Mathlib.RingTheory.Ideal.Colon.0.Submodule.colon._simp_3 | Mathlib.RingTheory.Ideal.Colon | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {s t : Set β} {a : α}, (a • s ⊆ t) = ∀ ⦃b : β⦄, b ∈ s → a • b ∈ t | null | false |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.dirichletUnitTheorem.seq_next._simp_1_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {ι : Type u_2} (s : Finset ι) (f : ι → NNReal), ∏ a ∈ s, ↑(f a) = ↑(∏ a ∈ s, f a) | null | false |
Rep.counitIso._proof_1 | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Monoid G],
RingHomInvPair (RingHom.id (MonoidAlgebra k G)) (RingHom.id (MonoidAlgebra k G)) | null | false |
Lean.Language.SnapshotTree.getAll | Lean.Language.Basic | Lean.Language.SnapshotTree → Array Lean.Language.Snapshot | Waits on and returns all snapshots in the tree. | true |
Int32.neg_neg | Init.Data.SInt.Lemmas | ∀ {a : Int32}, - -a = a | null | true |
LawfulFunctor.map_const | Init.Control.Lawful.Basic | ∀ {f : Type u → Type v} {inst : Functor f} [self : LawfulFunctor f] {α β : Type u},
Functor.mapConst = Functor.map ∘ Function.const β | The `mapConst` implementation is equivalent to the default implementation.
| true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.foundBVar | Lean.Meta.Tactic.Grind.EMatchTheorem | ℕ → Lean.Meta.Grind.NormalizePattern.M✝ Bool | null | true |
Classical.allZFSetDefinable | Mathlib.SetTheory.ZFC.Basic | {n : ℕ} → (F : (Fin n → ZFSet.{u}) → ZFSet.{u}) → ZFSet.Definable n F | All functions are classically definable. | true |
_private.Mathlib.Analysis.RCLike.Basic.0.RCLike._aux_Mathlib_Analysis_RCLike_Basic___macroRules__private_Mathlib_Analysis_RCLike_Basic_0_RCLike_termIR_1 | Mathlib.Analysis.RCLike.Basic | Lean.Macro | null | false |
instSliceableArrayNatSubarray_7 | Init.Data.Slice.Array.Basic | {α : Type u} → Std.Rio.Sliceable (Array α) ℕ (Subarray α) | null | true |
Int64.toInt32_ofIntLE | Init.Data.SInt.Lemmas | ∀ {n : ℤ} (h₁ : Int64.minValue.toInt ≤ n) (h₂ : n ≤ Int64.maxValue.toInt),
(Int64.ofIntLE n h₁ h₂).toInt32 = Int32.ofInt n | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go_denote_eq._proof_1_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | ∀ {w : ℕ} (distance curr idx : ℕ), curr < idx → ¬curr + 1 ≤ idx → False | null | false |
RatFunc.CompletionAtInfty.instField._proof_63 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (a : RatFunc.CompletionAtInfty F),
a ≠ 0 → a * a⁻¹ = 1 | null | false |
Submodule.span_setOfPred_mem_eq_top | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Set M},
Submodule.span R {x | ↑x ∈ s} = ⊤ | null | true |
toIcoMod_add_left' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIcoMod hp (p + a) b = p + toIcoMod hp a b | null | true |
AddHom.prod_apply | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Add M] [inst_1 : Add N] [inst_2 : Add P] (f : M →ₙ+ N)
(g : M →ₙ+ P) (x : M), (f.prod g) x = (f x, g x) | null | true |
QuadraticAlgebra.instField._proof_6 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {K : Type u_1} [inst : Field K] {a b : K}, 0⁻¹ = 0 | null | false |
PFun.comp | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (β →. γ) → (α →. β) → α →. γ | Composition of partial functions as a partial function. | true |
Nat.Partrec.Code.eval_pappAck | Mathlib.Computability.Ackermann | ∀ (m n : ℕ), (Nat.Partrec.Code.pappAck m).eval n = Part.some (ack m n) | null | true |
CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork._proof_5 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.Limits.HasZeroObject C]
(kf : CategoryTheory.Limits.KernelFork S.g) (hkf : CategoryTheory.Limits.IsLimit kf),
CategoryTheory.CategoryStruct.comp
... | null | false |
LinearMap.compr₂_apply | Mathlib.LinearAlgebra.BilinearMap | ∀ {A : Type u_1} {R : Type u_2} [inst : Semiring A] [inst_1 : CommSemiring R] {M : Type u_5} {Nₗ : Type u_8}
{Pₗ : Type u_9} {Qₗ : Type u_10} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid Nₗ] [inst_4 : AddCommMonoid Pₗ]
[inst_5 : AddCommMonoid Qₗ] [inst_6 : Module R Nₗ] [inst_7 : Module R Pₗ] [inst_8 : Module ... | null | true |
UInt8.le_iff_toFin_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a ≤ b ↔ a.toFin ≤ b.toFin | null | true |
Int.zero_add | Init.Data.Int.Lemmas | ∀ (a : ℤ), 0 + a = a | null | true |
SimpleGraph.coe_edgeFinset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype ↑G.edgeSet], ↑G.edgeFinset = G.edgeSet | null | true |
WittVector.frobeniusEquiv._proof_7 | Mathlib.RingTheory.WittVector.Frobenius | ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R] (x y : WittVector p R),
(↑↑WittVector.frobenius).toFun (x * y) = (↑↑WittVector.frobenius).toFun x * (↑↑WittVector.frobenius).toFun y | null | false |
Lean.Meta.instInhabitedCoeFnInfo | Lean.Meta.CoeAttr | Inhabited Lean.Meta.CoeFnInfo | null | true |
RBTree.RBNode.balance1_eq | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {c : RBTree.RBColor} {n : ℕ} {l : RBTree.RBNode α} {v : α} {r : RBTree.RBNode α},
l.Balanced c n → l.balance1 v r = RBTree.RBNode.node RBTree.RBColor.black l v r | The `balance1` function does nothing if the first argument is already balanced. | true |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.le_infDist._simp_1_3 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), (edist x y).toReal = dist x y | null | false |
Lean.Lsp.RpcRef.rec | Lean.Server.Rpc.Basic | {motive : Lean.Lsp.RpcRef → Sort u} → ((p : USize) → motive { p := p }) → (t : Lean.Lsp.RpcRef) → motive t | null | false |
_private.Batteries.Recycling.MonadSatisfying.Basic.0.SatisfiesM_EStateM_eq.match_1_1 | Batteries.Recycling.MonadSatisfying.Basic | ∀ {ε σ α : Type u_1} {p : α → Prop} (motive : EStateM.Result ε σ { a // p a } → Prop)
(x : EStateM.Result ε σ { a // p a }),
(∀ (a : { a // p a }) (s' : σ), x = EStateM.Result.ok a s' → motive (EStateM.Result.ok a s')) →
(∀ (e : ε) (s' : σ), x = EStateM.Result.error e s' → motive (EStateM.Result.error e s')) → ... | null | false |
inr_coprodIsoPushout_hom | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct X Y],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr (coprodIsoPushout X Y).hom =
... | null | true |
Combinatorics.Line.ColorFocused.mk.inj | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_5} {ι : Type u_6} {κ : Type u_7} {C : (ι → Option α) → κ}
{lines : Multiset (Combinatorics.Line.AlmostMono C)} {focus : ι → Option α}
{is_focused : ∀ p ∈ lines, ↑p.line none = focus}
{distinct_colors : (Multiset.map Combinatorics.Line.AlmostMono.color lines).Nodup}
{lines_1 : Multiset (Combinatori... | null | true |
_private.Mathlib.Data.Set.Card.0.Set.encard_le_coe_iff.match_1_1 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} {k : ℕ} (motive : (s.Finite ∧ ∃ n₀, s.encard = ↑n₀ ∧ n₀ ≤ k) → Prop)
(x : s.Finite ∧ ∃ n₀, s.encard = ↑n₀ ∧ n₀ ≤ k),
(∀ (left : s.Finite) (n₀ : ℕ) (hs : s.encard = ↑n₀) (hle : n₀ ≤ k), motive ⋯) → motive x | null | false |
FirstOrder.Language.Embedding.ofInjective._proof_1 | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
[L.IsAlgebraic] {f : L.Hom M N} {x : ℕ} (r : L.Relations x) (x_1 : Fin x → M),
FirstOrder.Language.Structure.RelMap r (⇑f ∘ x_1) ↔ FirstOrder.Language.Structure.RelMap r x_1 | null | false |
Aesop.GoalUnsafe.rec_3 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | null | false |
IsUnit.of_pow_eq_one | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] {n : ℕ} {a : M}, a ^ n = 1 → n ≠ 0 → IsUnit a | null | true |
_private.Lean.Parser.Syntax.0.Lean.Parser.Command.macro._regBuiltin.Lean.Parser.Command.macro.parenthesizer_35 | Lean.Parser.Syntax | IO Unit | null | false |
Additive.ext | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} {a b : Additive α}, Additive.toMul a = Additive.toMul b → a = b | null | true |
dite_iff_right_iff._simp_1 | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : p → Prop} {y : Prop}, ((if h : p then x h else y) ↔ y) = ∀ (h : p), x h ↔ y | null | false |
CategoryTheory.GrothendieckTopology.fullyFaithfulUliftYoneda | Mathlib.CategoryTheory.Sites.Canonical | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
[inst_1 : J.Subcanonical] → (CategoryTheory.GrothendieckTopology.uliftYoneda.{w, v, u} J).FullyFaithful | A variant of `yonedaFullyFaithful` with a raise in the universe level. | true |
CategoryTheory.AddMonObj.zero_rightUnitor | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M : C}
[inst_2 : CategoryTheory.AddMonObj M],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCateg... | null | true |
Std.Notify.Consumer.normal.inj | Std.Sync.Notify | ∀ {α : Type} {promise promise_1 : IO.Promise α},
Std.Notify.Consumer.normal promise = Std.Notify.Consumer.normal promise_1 → promise = promise_1 | null | true |
Lean.Meta.DefEqContext.recOn | Lean.Meta.Basic | {motive : Lean.Meta.DefEqContext → Sort u} →
(t : Lean.Meta.DefEqContext) →
((lhs rhs : Lean.Expr) →
(lctx : Lean.LocalContext) →
(localInstances : Lean.LocalInstances) →
motive { lhs := lhs, rhs := rhs, lctx := lctx, localInstances := localInstances }) →
motive t | null | false |
StrongDual.extendRCLikeL._proof_4 | Mathlib.Analysis.Normed.Module.RCLike.Extend | SMulCommClass ℝ ℝ ℝ | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.Precomp.obj.match_1.eq_2 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (motive : Fin (n + 1 + 1) → Sort u_1) (i : ℕ) (hi : i + 1 < n + 1 + 1)
(h_1 : (isLt : 0 < n + 1 + 1) → motive ⟨0, isLt⟩) (h_2 : (i : ℕ) → (hi : i + 1 < n + 1 + 1) → motive ⟨i.succ, hi⟩),
(match ⟨i.succ, hi⟩ with
| ⟨0, isLt⟩ => h_1 isLt
| ⟨i.succ, hi⟩ => h_2 i hi) =
h_2 i hi | null | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.rec | Std.Sync.Broadcast | {α : Type} →
{motive : Std.Bounded✝ α → Sort u} →
((state : Std.Mutex (Std.Bounded.State✝ α)) → motive { state := state }) → (t : Std.Bounded✝ α) → motive t | null | false |
EStateM.run_modify | Init.Control.Lawful.Instances | ∀ {σ ε : Type u_1} (f : σ → σ) (s : σ), (modify f).run s = EStateM.Result.ok PUnit.unit (f s) | null | true |
RingHom.algebraMap_toAlgebra | Mathlib.Algebra.Algebra.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (i : R →+* S), algebraMap R S = i | null | true |
ProofWidgets.RefreshToken.recOn | ProofWidgets.Component.RefreshComponent | {motive : ProofWidgets.RefreshToken → Sort u} →
(t : ProofWidgets.RefreshToken) →
((state : Std.Mutex ProofWidgets.RefreshComponent.RefreshState) →
(cancelTk : IO.CancelToken) →
(promise : IO.Ref (IO.Promise Unit)) → motive { state := state, cancelTk := cancelTk, promise := promise }) →
mo... | null | false |
CategoryTheory.ShortComplex.isLimitπ₃MapConeLimitCone._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C))
[inst_3 : CategoryTheory.Limits.HasLimit (F.comp CategoryTheory.ShortComp... | null | false |
not_subsingleton | Mathlib.Basic.Nontrivial.Defs | ∀ (α : Type u_3) [Nontrivial α], ¬Subsingleton α | null | true |
Std.ExtHashMap.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k fallback : α},
k ∉ m → l.contains k = false → (m.insertManyIfNewUnit l).getKeyD k fallback = fallback | null | true |
Module.Basis.det_inv | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {ι : Type u_4} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] {A : Type u_5}
[inst_3 : CommRing A] [inst_4 : Module A M] (b b' : Module.Basis ι A M), ↑⋯.unit⁻¹ = b'.det ⇑b | null | true |
optionProdEquiv._proof_2 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_2} {β : Type u_1} (x : β ⊕ α × β),
(Option.casesOn (Sum.casesOn x (Prod.mk none) (Prod.map some id)).1
(Sum.inl (Sum.casesOn x (Prod.mk none) (Prod.map some id)).2) fun a =>
Sum.inr (a, (Sum.casesOn x (Prod.mk none) (Prod.map some id)).2)) =
x | null | false |
instContinuousNegMulOpposite | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : TopologicalSpace R] [ContinuousNeg R], ContinuousNeg Rᵐᵒᵖ | null | true |
_private.Lean.Compiler.LCNF.Main.0.Lean.Compiler.LCNF.isValidMainType._sparseCasesOn_4 | Lean.Compiler.LCNF.Main | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.Num.Prime.0.PosNum.minFacAux.match_1.eq_1 | Mathlib.Data.Num.Prime | ∀ (motive : ℕ → PosNum → Sort u_1) (x : PosNum) (h_1 : (x : PosNum) → motive 0 x)
(h_2 : (fuel : ℕ) → (k : PosNum) → motive fuel.succ k),
(match 0, x with
| 0, x => h_1 x
| fuel.succ, k => h_2 fuel k) =
h_1 x | null | true |
Multiset.zero_add | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} (s : Multiset α), 0 + s = s | null | true |
finrank_of_isSplittingField_X_pow_sub_C | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u} [inst : Field K] {n : ℕ},
(primitiveRoots n K).Nonempty →
∀ {a : K},
Irreducible (Polynomial.X ^ n - Polynomial.C a) →
∀ (L : Type u_1) [inst_1 : Field L] [inst_2 : Algebra K L]
[Polynomial.IsSplittingField K L (Polynomial.X ^ n - Polynomial.C a)], Module.finrank K L = n | null | true |
_private.Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes.0.Mathlib.Tactic.Bicategory.Mor₂IsoOfExpr.match_1 | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | (motive : Lean.Name × Array Lean.Expr → Sort u_1) →
(x : Lean.Name × Array Lean.Expr) →
((head head_1 head_2 head_3 head_4 head_5 f g h : Lean.Expr) →
motive (`CategoryTheory.Bicategory.associator, #[head, head_1, head_2, head_3, head_4, head_5, f, g, h])) →
((head head_1 head_2 head_3 f : Lean.Expr... | null | false |
RCLike.re_eq_norm_of_mul_conj | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] (x : K), RCLike.re (x * (starRingEnd K) x) = ‖x * (starRingEnd K) x‖ | null | true |
_private.Init.Data.List.Attach.0.List.findSome?.match_1.eq_1 | Init.Data.List.Attach | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : (b : β) → motive (some b)) (h_2 : Unit → motive none),
(match some b with
| some b => h_1 b
| none => h_2 ()) =
h_1 b | null | true |
CategoryTheory.Square.isPullback_iff | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
sq.IsPullback ↔ Nonempty (CategoryTheory.Limits.IsLimit sq.pullbackCone) | null | true |
UInt64.toNat.eq_1 | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toNat = n.toBitVec.toNat | null | true |
FreeMonoid.map_of | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x : α), (FreeMonoid.map f) (FreeMonoid.of x) = FreeMonoid.of (f x) | null | true |
_private.Mathlib.RingTheory.SimpleRing.Congr.0.isSimpleRing_iff_isTwoSided_imp._simp_1_2 | Mathlib.RingTheory.SimpleRing.Congr | ∀ (α : Type u_4) [inst : LE α] [inst_1 : BoundedOrder α], IsSimpleOrder α = (Nontrivial α ∧ ∀ (a : α), a = ⊥ ∨ a = ⊤) | null | false |
_private.Mathlib.Geometry.Manifold.Instances.Real.0.instIsManifoldIcc._simp_4 | Mathlib.Geometry.Manifold.Instances.Real | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, (a < c - b) = (a + b < c) | null | false |
piecewise_ae_eq_restrict | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f g : α → β}
[inst_1 : DecidablePred fun x => x ∈ s], MeasureTheory.NullMeasurableSet s μ → s.piecewise f g =ᵐ[μ.restrict s] f | null | true |
_private.Mathlib.Probability.Independence.Process.HasIndepIncrements.IsGaussianProcess.0.Finset.orderEmbOfFinWithBot._proof_1 | Mathlib.Probability.Independence.Process.HasIndepIncrements.IsGaussianProcess | ∀ {T : Type u_1} (I : Finset T), NeZero (I.card + 1) | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.map_comp_forget | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
{F G : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} (α : F ⟶ G),
(CategoryTheory.Pseudofunctor.Grothendieck.map α).comp (CategoryTheory.Pseudofunctor.Grothendieck.forget G) =
CategoryTheory.Pseudofunctor.Grothe... | null | true |
String.Pos.ofSliceTo_startPos | Init.Data.String.Basic | ∀ {s : String} {pos : s.Pos}, String.Pos.ofSliceTo (s.sliceTo pos).startPos = s.startPos | null | true |
LinearMap.bijective_of_surjective_of_bijective_of_right_exact | Mathlib.Algebra.FiveLemma | ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_2} {M₂ : Type u_3} {M₃ : Type u_4} {N₁ : Type u_7} {N₂ : Type u_8}
{N₃ : Type u_9} [inst_1 : AddCommGroup M₁] [inst_2 : AddCommGroup M₂] [inst_3 : AddCommGroup M₃]
[inst_4 : Module R M₁] [inst_5 : Module R M₂] [inst_6 : Module R M₃] [inst_7 : AddCommGroup N₁]
[ins... | A special case of the five lemma in terms of modules. For a diagram explaining the variables,
see the module docstring. | true |
CategoryTheory.Abelian.LeftResolution.karoubi.π'._proof_3 | Mathlib.Algebra.Homology.LeftResolution.Reduced | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive A] [inst_4 : ι.Additive] ⦃X Y : ... | null | false |
CategoryTheory.RetractArrow.toLoc_i₂ | Mathlib.CategoryTheory.Bicategory.RetractArrow | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y X' Y' : C} {f' : X' ⟶ Y'} {f : X ⟶ Y}
(r : CategoryTheory.RetractArrow f' f), r.toLoc.i₂ = (CategoryTheory.Arrow.Hom.right r.i).toLoc | null | true |
CompletePartialOrder.mk.noConfusion | Mathlib.Order.CompletePartialOrder | {α : Type u_4} →
{P : Sort u} →
{toPartialOrder : PartialOrder α} →
{toSupSet : SupSet α} →
{toOrderBot : OrderBot α} →
{lubOfDirected : ∀ (d : Set α), DirectedOn (fun x1 x2 => x1 ≤ x2) d → IsLUB d (sSup d)} →
{toPartialOrder' : PartialOrder α} →
{toSupSet' : SupS... | null | false |
Submonoid.instSMulCommClassSubtypeMem_1 | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_3} {S' : Type u_4} [inst : SetLike S' M'] (s : S') [inst_1 : SMul α β]
[inst_2 : SMul M' β] [SMulCommClass α M' β], SMulCommClass α (↥s) β | null | true |
FreeLieAlgebra.Rel.brecOn | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R]
{motive : (a a_1 : FreeNonUnitalNonAssocAlgebra R X) → FreeLieAlgebra.Rel R X a a_1 → Prop}
{a a_1 : FreeNonUnitalNonAssocAlgebra R X} (t : FreeLieAlgebra.Rel R X a a_1),
(∀ (a a_2 : FreeNonUnitalNonAssocAlgebra R X) (t : FreeLieAlgebra.Rel R X a a_2),
FreeLie... | null | true |
Real.exp_strictMono | Mathlib.Analysis.Complex.Exponential | StrictMono Real.exp | null | true |
CompleteBooleanAlgebra.toCompleteDistribLattice | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → [CompleteBooleanAlgebra α] → CompleteDistribLattice α | null | true |
RingEquiv.piUnique | Mathlib.Algebra.Ring.Equiv | {ι : Type u_7} →
(R : ι → Type u_8) →
[inst : Unique ι] → [inst_1 : (i : ι) → NonUnitalNonAssocSemiring (R i)] → ((i : ι) → R i) ≃+* R default | Product of a singleton family of (non-unital non-associative semi)rings is isomorphic
to the only member of this family. | true |
ModelWithCorners.MfldCat.noConfusion | Mathlib.Geometry.Manifold.Category.MfldCat.OfModel | {P : Sort u_4} →
{𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{E : Type u_2} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : NormedSpace 𝕜 E} →
{H : Type u_3} →
{inst_3 : TopologicalSpace H} →
{I : ModelWithCorners 𝕜 E H} →
... | null | false |
CategoryTheory.Square.kernelFork | Mathlib.Algebra.Homology.Square | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(sq : CategoryTheory.Square C) →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct sq.X₂ sq.X₃] →
CategoryTheory.Limits.KernelFork (CategoryTheory.Limits.biprod.desc sq.f₂₄ (-sq.f₃₄)... | The kernel fork attached to a commutative square in a preadditive category. | true |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.extract.go₁.match_1.splitter | Batteries.Data.String.Lemmas | (motive : List Char → String.Pos.Raw → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 x_3 : String.Pos.Raw) →
((x x_4 x_5 : String.Pos.Raw) → motive [] x x_4 x_5) →
((c : Char) → (cs : List Char) → (i b e : String.Pos.Raw) → motive (c :: cs) i b e) → motive x x_1 x_2 x_3 | null | true |
Units.inv_le_one._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ), (↑u⁻¹ ≤ 1) = (1 ≤ ↑u) | null | false |
Finset.noncommProd_mul_distrib | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] {s : Finset α} (f g : α → β)
(comm_ff : (↑s).Pairwise (Function.onFun Commute f)) (comm_gg : (↑s).Pairwise (Function.onFun Commute g))
(comm_gf : (↑s).Pairwise fun x y => Commute (g x) (f y)),
s.noncommProd (f * g) ⋯ = s.noncommProd f comm_ff * s.noncommProd g com... | The non-commutative version of `Finset.prod_mul_distrib` | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.