name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Ideal.isCoprime_iff_exists | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1 | true |
Monotone.iterate_le_of_le | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f g : α → α}, Monotone f → f ≤ g → ∀ (n : ℕ), f^[n] ≤ g^[n] | true |
instCommCStarAlgebraForall._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → CommCStarAlgebra (A i)],
CompleteSpace ((i : ι) → A i) | false |
MeasureTheory.setIntegral_le_nonneg | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {f : X → ℝ} {s : Set X},
MeasurableSet s →
MeasureTheory.StronglyMeasurable f →
MeasureTheory.Integrable f μ → ∫ (x : X) in s, f x ∂μ ≤ ∫ (x : X) in {y | 0 ≤ f y}, f x ∂μ | true |
CategoryTheory.Functor.ShiftSequence.induced.isoZero | Mathlib.CategoryTheory.Shift.InducedShiftSequence | {C : Type u_1} →
{D : Type u_2} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D ... | true |
Nat.recOnPrimePow._proof_1 | Mathlib.Data.Nat.Factorization.Induction | ∀ {motive : ℕ → Sort u_1} (k : ℕ),
motive (k + 2) =
motive
((k + 2).minFac ^ (k + 2).factorization (k + 2).minFac *
((k + 2) / (k + 2).minFac ^ (k + 2).factorization (k + 2).minFac)) | false |
EsakiaHomClass.toContinuousOrderHomClass | Mathlib.Topology.Order.Hom.Esakia | ∀ {F : Type u_6} {α : outParam (Type u_7)} {β : outParam (Type u_8)} {inst : TopologicalSpace α} {inst_1 : Preorder α}
{inst_2 : TopologicalSpace β} {inst_3 : Preorder β} {inst_4 : FunLike F α β} [self : EsakiaHomClass F α β],
ContinuousOrderHomClass F α β | true |
_private.Mathlib.Probability.Kernel.Disintegration.CDFToKernel.0.ProbabilityTheory.setLIntegral_stieltjesOfMeasurableRat._simp_1_4 | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | false |
_private.Batteries.Tactic.Lint.Simp.0.Batteries.Tactic.Lint.simpNF.match_7 | Batteries.Tactic.Lint.Simp | (motive : Batteries.Tactic.Lint.SimpTheoremInfo → Sort u_1) →
(x : Batteries.Tactic.Lint.SimpTheoremInfo) →
((hyps : Array Lean.Expr) → (lhs rhs : Lean.Expr) → motive { hyps := hyps, lhs := lhs, rhs := rhs }) → motive x | false |
CategoryTheory.hasCoseparator_op_iff | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.HasCoseparator Cᵒᵖ ↔ CategoryTheory.HasSeparator C | true |
List.find?_range'_eq_none | Init.Data.List.Nat.Range | ∀ {s n : ℕ} {p : ℕ → Bool}, List.find? p (List.range' s n) = none ↔ ∀ (i : ℕ), s ≤ i → i < s + n → (!p i) = true | true |
Lean.forEachModuleInDir._unsafe_rec | Lean.Util.Path | {m : Type → Type u_1} → [Monad m] → [MonadLiftT IO m] → System.FilePath → (Lean.Name → m PUnit.{1}) → m PUnit.{1} | false |
Fin.cycleRange_apply | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} [inst : NeZero n] (i j : Fin n), i.cycleRange j = if j < i then j + 1 else if j = i then 0 else j | true |
NormOneClass.rec | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
[inst : Norm α] →
[inst_1 : One α] →
{motive : NormOneClass α → Sort u} → ((norm_one : ‖1‖ = 1) → motive ⋯) → (t : NormOneClass α) → motive t | false |
Matroid.isLoop_iff_closure_eq_loops_and_mem_ground | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e ↔ M.closure {e} = M.loops ∧ e ∈ M.E | true |
_private.Std.Sync.Broadcast.0.Std.instReprSlot | Std.Sync.Broadcast | {α : Type} → [Repr α] → Repr (Std.Slot✝ α) | true |
_private.Mathlib.RingTheory.Trace.Quotient.0.Algebra.trace_quotient_eq_of_isDedekindDomain._proof_1_1 | Mathlib.RingTheory.Trace.Quotient | ∀ {R : Type u_2} (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsMaximal],
IsLocalization (Submonoid.map (algebraMap R S) p.primeCompl)
(Localization (Algebra.algebraMapSubmonoid S p.primeCompl)) | false |
_private.Mathlib.Topology.Closure.0.mem_interior._simp_1_4 | Mathlib.Topology.Closure | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | false |
CategoryTheory.Limits.biprod.mapIso_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{W X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X]
[inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] (f : W ≅ Y) (g : X ≅ Z),
(CategoryTheory.Limits.biprod.mapIso f g).hom = Ca... | true |
CategoryTheory.PreZeroHypercover.refineOneHypercover_p₂ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
[inst_1 : E.HasPullbacks]
(F : (i j : E.I₀) → CategoryTheory.PreZeroHypercover (CategoryTheory.Limits.pullback (E.f i) (E.f j))) (i j : E.I₀)
(k : (F i j).I₀),
(E.refineOneHypercover F).p₂ k =
CategoryT... | true |
Asymptotics.IsBigOWith.smul | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} {R : Type u_13} {𝕜' : Type u_16} [inst : SeminormedAddCommGroup E']
[inst_1 : SeminormedAddCommGroup F'] [inst_2 : SeminormedRing R] [inst_3 : NormedDivisionRing 𝕜'] {c c' : ℝ}
{f' : α → E'} {g' : α → F'} {l : Filter α} [inst_4 : Module R E'] [IsBoundedSMul R E'] [... | true |
orbit_subgroup_eq_rightCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) (a : α), MulAction.orbit (↥s) a = MulOpposite.op a • ↑s | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.mkNullaryCtor.match_1 | Lean.Meta.WHNF | (motive : Option Lean.Name → Sort u_1) →
(__discr : Option Lean.Name) →
((ctor : Lean.Name) → motive (some ctor)) → ((x : Option Lean.Name) → motive x) → motive __discr | false |
DilationEquiv.symm_trans_self | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (e : X ≃ᵈ Y),
e.symm.trans e = DilationEquiv.refl Y | true |
CategoryTheory.instFullAlgebraToMonadAdjComparison | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C),
(CategoryTheory.Monad.comparison T.adj).Full | true |
Lean.Lsp.DocumentSymbolAux._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | (Self : Type) → [SizeOf Self] → SizeOf (Lean.Lsp.DocumentSymbolAux Self) | false |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.PNat.instHasAntidiagonal._simp_2 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {α : Type u_1} (s : Finset α) (x : ↥s), (x ∈ s.attach) = True | false |
MeasureTheory.AEStronglyMeasurable.const_smul' | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {𝕜 : Type u_5} [inst_1 : SMul 𝕜 β] [ContinuousConstSMul 𝕜 β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : 𝕜), MeasureTheory.AEStronglyMeasurable (fun x => c • f x) μ | true |
_private.Mathlib.Algebra.Polynomial.EraseLead.0.Polynomial.mono_map_natDegree_eq.match_1_1 | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R) (motive : f.natDegree < 0 → Prop) (FG : f.natDegree < 0),
motive FG | false |
MeasureTheory.Measure.le_iff | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ : MeasureTheory.Measure α},
μ₁ ≤ μ₂ ↔ ∀ (s : Set α), MeasurableSet s → μ₁ s ≤ μ₂ s | true |
Sublattice.instLatticeCoe._proof_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (L : Sublattice α), Function.Injective fun a => ↑a | false |
AbsoluteValue.nonneg' | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : PartialOrder S]
(self : AbsoluteValue R S) (x : R), 0 ≤ self.toFun x | true |
Std.DHashMap.Internal.Raw₀.Const.distinct_keys_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m).WF → List.Pairwise (fun a b => (a.1 == b.1) = false) (Std.DHashMap.Raw.Const.toList ↑m) | true |
Eq.casesOn | Init.Prelude | {α : Sort u_1} →
{a : α} → {motive : (a_1 : α) → a = a_1 → Sort u} → {a_1 : α} → (t : a = a_1) → motive a ⋯ → motive a_1 t | false |
_private.Batteries.Data.Char.Basic.0.Char.of_all_eq_true_aux._proof_1_6 | Batteries.Data.Char.Basic | ∀ (x : Fin 55296), ↑x < 55296 ∨ 57343 < ↑x ∧ ↑x < 1114112 | false |
Lean.Meta.RewriteResult.rec | Lean.Meta.Tactic.Rewrite | {motive : Lean.Meta.RewriteResult → Sort u} →
((eNew eqProof : Lean.Expr) →
(mvarIds : List Lean.MVarId) → motive { eNew := eNew, eqProof := eqProof, mvarIds := mvarIds }) →
(t : Lean.Meta.RewriteResult) → motive t | false |
Std.Tactic.BVDecide.BVLogicalExpr.eval_literal | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {pred : Std.Tactic.BVDecide.BVPred},
Std.Tactic.BVDecide.BVLogicalExpr.eval assign (Std.Tactic.BVDecide.BoolExpr.literal pred) =
Std.Tactic.BVDecide.BVPred.eval assign pred | true |
CategoryTheory.Limits.coconePointwiseProduct_ι_app | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type w} {I : α → Type u₁}
[inst_1 : (i : α) → CategoryTheory.Category.{v₁, u₁} (I i)]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete α) C]
(F : (i : α) → CategoryTheory.Functor (I i) C) [inst_3 : ∀ (i : α), CategoryTheory.Lim... | true |
Set.preimage_mul_const_Ici | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => x * a) ⁻¹' Set.Ici b = Set.Ici (b / a) | true |
FreeAlgebra.definition._@.Mathlib.Algebra.FreeAlgebra.2097919375._hygCtx._hyg.2 | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → {X : Type u_2} → [inst : CommSemiring R] → X → FreeAlgebra R X | false |
Turing.TM0.Cfg.mk.sizeOf_spec | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} [inst : Inhabited Γ] [inst_1 : SizeOf Γ] [inst_2 : SizeOf Λ] (q : Λ)
(Tape : Turing.Tape Γ), sizeOf { q := q, Tape := Tape } = 1 + sizeOf q + sizeOf Tape | true |
ne_of_ssubset | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSSubset α] [Std.Irrefl fun x1 x2 => x1 ⊂ x2] {a b : α}, a ⊂ b → a ≠ b | true |
MeasureTheory.unifIntegrable_fin | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{p : ENNReal},
1 ≤ p →
p ≠ ⊤ →
∀ {n : ℕ} {f : Fin n → α → β}, (∀ (i : Fin n), MeasureTheory.MemLp (f i) p μ) → MeasureTheory.UnifIntegrable f p μ | true |
Lean.Linter.UnusedVariables.FVarDefinition.mk.injEq | Lean.Linter.UnusedVariables | ∀ (userName : Lean.Name) (stx : Lean.Syntax) (opts : Lean.Options) (aliases : Array Lean.FVarId)
(userName_1 : Lean.Name) (stx_1 : Lean.Syntax) (opts_1 : Lean.Options) (aliases_1 : Array Lean.FVarId),
({ userName := userName, stx := stx, opts := opts, aliases := aliases } =
{ userName := userName_1, stx := st... | true |
Lean.Meta.Structural.isInstHPowNat | Lean.Meta.NatInstTesters | Lean.Expr → Lean.MetaM Bool | true |
List.Forall₂.nil | Batteries.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}, List.Forall₂ R [] [] | true |
Lean.Parser.AliasValue.const.noConfusion | Lean.Parser.Extension | {α : Type} →
{P : Sort u} → {p p' : α} → Lean.Parser.AliasValue.const p = Lean.Parser.AliasValue.const p' → (p ≍ p' → P) → P | false |
List.getLast_of_mem_getLast? | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {l : List α} (hx : x ∈ l.getLast?), l.getLast ⋯ = x | true |
ZeroAtInftyContinuousMap.instNonUnitalNonAssocSemiring | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : NonUnitalNonAssocSemiring β] →
[IsTopologicalSemiring β] → NonUnitalNonAssocSemiring (ZeroAtInftyContinuousMap α β) | true |
Aesop.UnfoldRule.recOn | Aesop.Rule | {motive : Aesop.UnfoldRule → Sort u} →
(t : Aesop.UnfoldRule) →
((decl : Lean.Name) → (unfoldThm? : Option Lean.Name) → motive { decl := decl, unfoldThm? := unfoldThm? }) →
motive t | false |
Std.Do.SPred.pure_elim_r | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {Q R : Std.Do.SPred σs} {φ : Prop}, (φ → Q ⊢ₛ R) → Q ∧ ⌜φ⌝ ⊢ₛ R | true |
Lean.Meta.LazyDiscrTree.PreDiscrTree.roots | Lean.Meta.LazyDiscrTree | {α : Type} → Lean.Meta.LazyDiscrTree.PreDiscrTree α → Std.HashMap Lean.Meta.LazyDiscrTree.Key ℕ | true |
IsLocalization.AtPrime.liesOver_comap_of_liesOver | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Rₚ : Type u_3) [inst_4 : CommRing Rₚ] [inst_5 : Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p]
[inst_7 : IsLocalRing Rₚ] {T : Type u_5} [inst_8 : CommRing T] [inst_9 : Algebra R T] [inst... | true |
AlgebraicGeometry.IsProper.rec | Mathlib.AlgebraicGeometry.Morphisms.Proper | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsProper f → Sort u_1} →
([toIsSeparated : AlgebraicGeometry.IsSeparated f] →
[toUniversallyClosed : AlgebraicGeometry.UniversallyClosed f] →
[toLocallyOfFiniteType : AlgebraicGeometry.LocallyOfFiniteType f] →... | false |
instLawfulCommIdentityUInt8HMulOfNat | Init.Data.UInt.Lemmas | Std.LawfulCommIdentity (fun x1 x2 => x1 * x2) 1 | true |
Equiv.psigmaCongrRight._proof_4 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β₁ : α → Sort u_2} {β₂ : α → Sort u_3} (F : (a : α) → β₁ a ≃ β₂ a),
Function.RightInverse (fun a => ⟨a.fst, (F a.fst).symm a.snd⟩) fun a => ⟨a.fst, (F a.fst) a.snd⟩ | false |
SimpleGraph.mem_incidenceSet._simp_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) (v w : V), (s(v, w) ∈ G.incidenceSet v) = G.Adj v w | false |
Array.instDecidableEmpEq._proof_2 | Init.Data.Array.DecidableEq | ∀ {α : Type u_1} (head : α) (tail : List α), #[] = { toList := head :: tail } → False | false |
Lean.Elab.autoImplicit | Lean.Elab.AutoBound | Lean.Option Bool | true |
AddLeftCancelMonoid | Mathlib.Algebra.Group.Defs | Type u → Type u | true |
MeasureTheory.Ioo_ae_eq_Icc | Mathlib.MeasureTheory.Measure.Typeclasses.NoAtoms | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.NoAtoms μ]
[inst : PartialOrder α] {a b : α}, Set.Ioo a b =ᵐ[μ] Set.Icc a b | true |
pairSelfAdjointMatricesSubmodule._proof_2 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} [inst : CommRing R], RingHomSurjective (RingHom.id R) | false |
HomotopyCategory.isoOfHomotopyEquiv._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory | ∀ {ι : Type u_1} {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (f : HomotopyEquiv C D),
CategoryTheory.CategoryStruct.comp ((HomotopyCategory.quotient V c).map f.hom)
((HomotopyCategory.quotient V c).map... | false |
SimpleGraph.Subgraph.IsMatching.not_adj_left_of_ne | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u_1} {G : SimpleGraph V} {M : G.Subgraph} {u v w : V}, M.IsMatching → v ≠ w → M.Adj u v → ¬M.Adj u w | true |
_private.Mathlib.Analysis.Calculus.DerivativeTest.0.continuousOn_Ici | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {a : ℝ}, ContinuousAt f a → DifferentiableOn ℝ f (Set.Ioi a) → ContinuousOn f (Set.Ici a) | true |
AlgebraicTopology.DoldKan.Γ₀.obj._proof_2 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) {Δ'' Δ' Δ : SimplexCategoryᵒᵖ}
(θ' : Δ'' ⟶ Δ') (θ : Δ' ⟶ Δ),
AlgebraicTopology.DoldKan.Γ₀.Obj.map K (CategoryTheory.CategoryStruct.co... | false |
NonemptyChain.mk.inj | Mathlib.Order.BourbakiWitt | ∀ {α : Type u_2} {inst : LE α} {carrier : Set α} {Nonempty' : carrier.Nonempty}
{isChain' : IsChain (fun x1 x2 => x1 ≤ x2) carrier} {carrier_1 : Set α} {Nonempty'_1 : carrier_1.Nonempty}
{isChain'_1 : IsChain (fun x1 x2 => x1 ≤ x2) carrier_1},
{ carrier := carrier, Nonempty' := Nonempty', isChain' := isChain' } =... | true |
Matroid._aux_Mathlib_Combinatorics_Matroid_Minor_Restrict___unexpand_Matroid_IsRestriction_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure.0.AlgebraicClosure.toSplittingField_coeff._simp_1_1 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ⇑f = ⇑↑f | false |
Lean.Parser.Term.doSeqBracketed.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | true |
CategoryTheory.GrothendieckTopology.Point.toPresheafFiberOfIsCofiltered_w | Mathlib.CategoryTheory.Sites.Point.OfIsCofiltered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{N : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} N] (p : CategoryTheory.Functor N C)
[inst_3 : CategoryTheory.InitiallySmall N] {J : CategoryTheory.GrothendieckTopology C}
[inst_4 : CategoryTheory.I... | true |
_private.Mathlib.Data.List.Lattice.0.List.bagInter.match_1.eq_1 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (x : List α) (h_1 : (x : List α) → motive [] x)
(h_2 : (x : List α) → motive x []) (h_3 : (a : α) → (l₁ l₂ : List α) → motive (a :: l₁) l₂),
(match [], x with
| [], x => h_1 x
| x, [] => h_2 x
| a :: l₁, l₂ => h_3 a l₁ l₂) =
h_1 x | true |
Turing.TM1to1.supportsStmt_read | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (dec : List.Vector Bool n → Γ)
{S : Finset (Turing.TM1to1.Λ' Γ Λ σ)} {f : Γ → Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ},
(∀ (a : Γ), Turing.TM1.SupportsStmt S (f a)) → Turing.TM1.SupportsStmt S (Turing.TM1to1.read dec f) | true |
CategoryTheory.NonPreadditiveAbelian.preadditive._proof_4 | Mathlib.CategoryTheory.Abelian.NonPreadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C]
(X Y : C) (n : ℕ) (a : X ⟶ Y), zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a | false |
CategoryTheory.Lax.LaxTrans.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
(app : (a : B) → F.obj a ⟶ G.obj a) →
(naturality :
{a b : B} →
(f : a ⟶ b) →
... | false |
Lean.Meta.Grind.SplitSource.ematch.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{origin origin' : Lean.Meta.Grind.Origin} →
Lean.Meta.Grind.SplitSource.ematch origin = Lean.Meta.Grind.SplitSource.ematch origin' → (origin = origin' → P) → P | false |
Matroid.eRank_eq_zero_iff | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α}, M.eRank = 0 ↔ M = Matroid.loopyOn M.E | true |
PiTensorProduct.lifts_add | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {x y : PiTensorProduct R fun i => s i}
{p q : FreeAddMonoid (R × ((i : ι) → s i))}, p ∈ x.lifts → q ∈ y.lifts → p + q ∈ (x + y).lifts | true |
Polynomial.trinomial_mirror | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {R : Type u_1} [inst : Semiring R] {k m n : ℕ} {u v w : R},
k < m → m < n → u ≠ 0 → w ≠ 0 → (Polynomial.trinomial k m n u v w).mirror = Polynomial.trinomial k (n - m + k) n w v u | true |
LinearEquiv.ofFinrankEq | Mathlib.LinearAlgebra.Dimension.Free | {R : Type u} →
(M : Type v) →
(M' : Type v') →
[inst : Semiring R] →
[StrongRankCondition R] →
[inst_2 : AddCommMonoid M] →
[inst_3 : Module R M] →
[Module.Free R M] →
[inst_5 : AddCommMonoid M'] →
[inst_6 : Module R M'] →
... | true |
Lean.Environment.findRedundantImports | ImportGraph.Imports.Redundant | Lean.Environment → Array Lean.Name → Lean.NameSet | true |
Std.Internal.IO.Async.Signal.sigquit.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 2 → motive Std.Internal.IO.Async.Signal.sigquit → motive t | false |
Std.Internal.IO.Process.PId.mk.injEq | Std.Internal.Async.Process | ∀ (toUInt64 toUInt64_1 : UInt64), ({ toUInt64 := toUInt64 } = { toUInt64 := toUInt64_1 }) = (toUInt64 = toUInt64_1) | true |
HasMemOrInvMem | Mathlib.Algebra.Group.Subgroup.Defs | {S : Type u_3} → {G : Type u_4} → [Inv G] → [SetLike S G] → S → Prop | true |
UInt8.ofNatLT_eq_ofNat | Init.Data.UInt.Lemmas | ∀ (n : ℕ) {h : n < UInt8.size}, UInt8.ofNatLT n h = UInt8.ofNat n | true |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpAppArgRange.visit | Lean.Meta.Sym.Simp.App | ℕ → Lean.Expr → ℕ → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
SimpleGraph.Iso.mapEdgeSet._proof_4 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ≃g G'),
Function.RightInverse (SimpleGraph.Hom.mapEdgeSet (RelIso.toRelEmbedding f.symm).toRelHom)
(SimpleGraph.Hom.mapEdgeSet (RelIso.toRelEmbedding f).toRelHom) | false |
pathComponentIn_mem_nhds | Mathlib.Topology.Connected.LocPathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} {F : Set X} [LocPathConnectedSpace X],
F ∈ nhds x → pathComponentIn F x ∈ nhds x | true |
Fin.sum_Ioc_cast | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] {n m : ℕ} (h : n = m) (f : Fin m → M) (a b : Fin n),
∑ i ∈ Finset.Ioc (Fin.cast h a) (Fin.cast h b), f i = ∑ i ∈ Finset.Ioc a b, f (Fin.cast h i) | true |
AddSubmonoid.mem_bot._simp_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, (x ∈ ⊥) = (x = 0) | false |
Lean.Elab.Term.derivableRef | Lean.Elab.Term.TermElabM | IO.Ref Lean.NameSet | true |
Nat.exists_infinite_pseudoprimes | Mathlib.NumberTheory.FermatPsp | ∀ {b : ℕ}, 1 ≤ b → ∀ (m : ℕ), ∃ n, n.FermatPsp b ∧ m ≤ n | true |
instTransLE | Mathlib.Order.Defs.PartialOrder | {α : Type u_1} → [inst : Preorder α] → Trans LE.le LE.le LE.le | true |
Order.IsPredLimit | Mathlib.Order.SuccPred.Limit | {α : Type u_1} → [Preorder α] → α → Prop | true |
_private.Mathlib.Algebra.Category.Ring.Epi.0.RingHom.surjective_of_epi_of_finite._proof_1_1 | Mathlib.Algebra.Category.Ring.Epi | ∀ {R S : CommRingCat} (f : R ⟶ S) [CategoryTheory.Epi f], CategoryTheory.Epi (CommRingCat.ofHom (algebraMap ↑R ↑S)) | false |
PrincipalSeg.ext | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Irrefl s] [Std.Trichotomous s]
{f g : PrincipalSeg r s}, (∀ (x : α), f.toRelEmbedding x = g.toRelEmbedding x) → f = g | true |
Lean.Parser.Syntax.atom._regBuiltin.Lean.Parser.Syntax.atom_1 | Lean.Parser.Syntax | IO Unit | false |
MulAction.BlockMem.instBoundedOrder | Mathlib.GroupTheory.GroupAction.Blocks | (G : Type u_1) →
[inst : Group G] → {X : Type u_2} → [inst_1 : MulAction G X] → (a : X) → BoundedOrder (MulAction.BlockMem G a) | true |
_private.Lean.Meta.Tactic.Grind.Order.Assert.0.Lean.Meta.Grind.Order.propagateLT | Lean.Meta.Tactic.Grind.Order.Assert | Lean.Meta.Grind.Propagator | true |
finsum_false | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : False → M), ∑ᶠ (i : False), f i = 0 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.