name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
convexHull.eq_1 | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], convexHull 𝕜 = ClosureOperator.ofCompletePred (Convex 𝕜) ⋯ | true |
_private.Lean.Meta.TryThis.0.Lean.Meta.Tactic.TryThis.Suggestion.processEdit.match_1 | Lean.Meta.TryThis | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((indent column : ℕ) → motive (indent, column)) → motive x | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_eq_iff._proof_1_6 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ},
(∃ k',
k ≤ k' ∧
k' ≤ stackPos ∧ String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1)) →
∀ (k' : ℕ), k ≤ k' → ¬k < k' → ¬k = k' → False | false |
CategoryTheory.Over.fst_left | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
{R S : CategoryTheory.Over X},
(CategoryTheory.SemiCartesianMonoidalCategory.fst R S).left = CategoryTheory.Limits.pullback.fst R.hom S.hom | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_motive._simp_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.Finset.aemeasurable_sum.match_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {ι : Type u_1} {α : Type u_3} {f : ι → α → M} (s : Finset ι) (_g : α → M)
(motive : (∃ a ∈ s.val, f a = _g) → Prop) (x : ∃ a ∈ s.val, f a = _g),
(∀ (_i : ι) (hi : _i ∈ s.val) (hg : f _i = _g), motive ⋯) → motive x | false |
CategoryTheory.Limits.inr_comp_pushoutComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : X ⟶ Y) (g : X ⟶ Z)
[inst_2 : CategoryTheory.Limits.HasPushout f g] [inst_3 : CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
{Z_1 : D} (h : G... | true |
CommRingCat.Under.tensorProductFan' | Mathlib.Algebra.Category.Ring.Under.Limits | {R : CommRingCat} →
(S : CommRingCat) →
[inst : Algebra ↑R ↑S] →
{ι : Type u} →
(P : ι → CategoryTheory.Under R) →
CategoryTheory.Limits.Fan fun i => S.mkUnder (TensorProduct ↑R ↑S ↑(P i).right) | true |
Std.TreeMap.contains_iff_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {k : α}, t.contains k = true ↔ k ∈ t | true |
Pi.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedRing (R i)] (n : ℕ) (x : (i : ι) → R i),
Semiring.npow (n + 1) x = Semiring.npow n x * x | false |
Mathlib.Tactic.LinearCombination.expandLinearCombo._unsafe_rec | Mathlib.Tactic.LinearCombination | Option Lean.Expr → Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.LinearCombination.Expanded | false |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.A_c_eq_zero | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {m : ℤ} {A : FixedDetMatrix (Fin 2) ℤ m}, ↑A 1 0 = 0 → ↑A 0 0 * ↑A 1 1 = m | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift_self | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (h : D.IsTerminal e),
h.lift ⋯ = CategoryTheory.CategoryStruct.id e | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_34 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (acc : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n),
(Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ofArray_fold_fn acc (some c)).size = n →
∀ (l : Std.Tactic.BVDecide.LRAT.Internal.PosFi... | false |
Lean.Meta.Simp.Methods.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {pre post : Lean.Meta.Simp.Simproc} {dpre dpost : Lean.Meta.Simp.DSimproc}
{discharge? : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge : Bool}
{pre_1 post_1 : Lean.Meta.Simp.Simproc} {dpre_1 dpost_1 : Lean.Meta.Simp.DSimproc}
{discharge?_1 : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)... | true |
Lean.ReducibilityHints.opaque.sizeOf_spec | Lean.Declaration | sizeOf Lean.ReducibilityHints.opaque = 1 | true |
Std.Time.Modifier.z.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.ZoneName} →
Std.Time.Modifier.z presentation = Std.Time.Modifier.z presentation' → (presentation = presentation' → P) → P | false |
CategoryTheory.equivSmallModel._proof_1 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.EssentiallySmall.{u_1, u_3, u_2} C], Nonempty (C ≌ Classical.choose ⋯) | false |
IsSolvableByRad.rec | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
{motive : (a : E) → IsSolvableByRad F a → Prop},
(∀ (α : F), motive ((algebraMap F E) α) ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRad F β), motive α a → motive β a_1 → motive (α + β) ⋯) →
(∀ (α... | false |
Polynomial.revAt_le | Mathlib.Algebra.Polynomial.Reverse | ∀ {N i : ℕ}, i ≤ N → (Polynomial.revAt N) i = N - i | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termY₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | true |
AddEquiv.strictMono_subsemigroupCongr | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : AddCommMonoid G] [inst_1 : Preorder G] {S T : AddSubsemigroup G} (h : S = T),
StrictMono ⇑(AddEquiv.subsemigroupCongr h) | true |
IsEmpty.oriented._proof_1 | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R], 1 ≠ 0 | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.uaddOverflow_assoc._simp_1_4 | Init.Data.BitVec.Lemmas | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | false |
derivedSet | Mathlib.Topology.DerivedSet | {X : Type u_1} → [TopologicalSpace X] → Set X → Set X | true |
SupHom.rec | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_sup' }) →
(t : SupHom α... | false |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_5 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n),
(AffineIndependent k fun a => if h : a = 0 then ⋯ ▸ s.centroid else s.points a) →
AffineIndependent k fun x => if x = 0 then s.centr... | false |
BitVec.mk_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {h : 0 < 2 ^ w}, { toFin := ⟨0, h⟩ } = 0#w | true |
Tropical.le_zero._simp_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LE R] [inst_1 : OrderTop R] (x : Tropical R), (x ≤ 0) = True | false |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Bool → Std.Tactic.BVDecide.LRAT.Internal.Assignment → Std.Tactic.BVDecide.LRAT.Internal.Assignment | true |
SSet.instIsStableUnderCoproductsMonomorphismsOfHasCoproductsType | Mathlib.AlgebraicTopology.SimplicialSet.Monomorphisms | ∀ [CategoryTheory.Limits.HasCoproducts (Type u)],
CategoryTheory.MorphismProperty.IsStableUnderCoproducts.{v', u, u + 1}
(CategoryTheory.MorphismProperty.monomorphisms SSet) | true |
_private.Mathlib.Analysis.Analytic.Binomial.0.Real.one_div_one_sub_rpow_hasFPowerSeriesOnBall_zero._simp_1_10 | Mathlib.Analysis.Analytic.Binomial | ∀ (r s : ℝ), ↑r - ↑s = ↑(r - s) | false |
Ideal.fiberIsoOfBijectiveResidueField._proof_7 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommRing R'] [inst_2 : Algebra R R'] {q : Ideal R'}
[inst_3 : q.IsPrime], SMulCommClass R q.ResidueField q.ResidueField | false |
_private.Mathlib.Analysis.Convex.Segment.0.mem_openSegment_translate._simp_1_2 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} {G : Type u_4} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : AddCommGroup G] [inst_5 : Module 𝕜 E] [inst_6 : AddTorsor G E]
[VAddCommClass G E E] (a : G) (b c : E), openSegment 𝕜 (a +ᵥ b) (a +ᵥ c) = a +ᵥ openSegment 𝕜 b c | false |
ContinuousLinearEquiv.comp_contDiffWithinAt_iff | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {f : E → F} {x : E} {n : ... | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_8 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
AlgebraicGeometry.Scheme.ProEt.forget | Mathlib.AlgebraicGeometry.Sites.Proetale | (S : AlgebraicGeometry.Scheme) → CategoryTheory.Functor S.ProEt (CategoryTheory.Over S) | true |
CategoryTheory.ObjectProperty.isThin_of_isSeparating_bot | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], ⊥.IsSeparating → Quiver.IsThin C | true |
Vector.append_assoc._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m k : ℕ}, n + (m + k) = n + m + k | false |
Aesop.RuleStatsTotals.empty | Aesop.Stats.Basic | Aesop.RuleStatsTotals | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.SavedState.termState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.SavedState✝ → Lean.Elab.Term.SavedState | true |
Lean.IR.IRType.usize | Lean.Compiler.IR.Basic | Lean.IR.IRType | true |
KummerDedekind.quotMapEquivQuotQuotMap._proof_4 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R}
[inst_3 : IsDomain R] [inst_4 : IsIntegrallyClosed R] [inst_5 : IsDedekindDomain S]
[inst_6 : Module.IsTorsionFree R S] (hx' : IsIntegral R x),
(Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (... | false |
_private.Mathlib.Probability.Kernel.Representation.0.ProbabilityTheory.Kernel.exists_measurable_map_eq_unitInterval_aux._simp_1_12 | Mathlib.Probability.Kernel.Representation | ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, (sSup s ≤ a) = ∀ b ∈ s, b ≤ a | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
... | true |
CategoryTheory.Presieve.singleton_eq_iff_domain._simp_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : Y ⟶ X),
CategoryTheory.Presieve.singleton f g = (f = g) | false |
sInfHom.ext | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] {f g : sInfHom α β},
(∀ (a : α), f a = g a) → f = g | true |
Lean.IR.EmitLLVM.constIntSizeT | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → ℕ → Lean.IR.EmitLLVM.M llvmctx (LLVM.Value llvmctx) | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence.0.Mathlib.Tactic.BicategoryLike.normalize.match_3 | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | (motive : Mathlib.Tactic.BicategoryLike.Mor₁ → Sort u_1) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
((e : Lean.Expr) → (a : Mathlib.Tactic.BicategoryLike.Obj) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.id e a)) →
((e : Lean.Expr) →
(f g : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.T... | false |
CategoryTheory.ShortComplex.SnakeInput.functorL₃._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).f₃ = CategoryTheory.CategoryStruct.comp f.f₃ g.f₃ | false |
Fin.val_mk | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (h : m < n), ↑⟨m, h⟩ = m | true |
MulOpposite.instAddCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [AddCommSemigroup α] → AddCommSemigroup αᵐᵒᵖ | true |
_private.Mathlib.Analysis.InnerProductSpace.l2Space.0.HilbertBasis.dense_span._simp_1_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
_private.Mathlib.NumberTheory.ModularForms.Bounds.0.ModularGroup.exists_bound_of_invariant_of_isBigO._simp_1_4 | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
Std.ExtTreeMap.minKeyD_le_minKeyD_erase | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true | true |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.Chain.pair.match_1.eq_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (x : ℕ) → motive x),
(x = 0 → False) →
(match x with
| 0 => h_1 ()
| x => h_2 x) =
h_2 x | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.BifunctorCokernel.0.CategoryTheory.Limits.CokernelCofork.mapBifunctor._simp_2 | Mathlib.CategoryTheory.Limits.Preserves.BifunctorCokernel | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.of_le.match_1_3 | Batteries.Data.BinomialHeap.Basic | ∀ {n' : ℕ} {α : Type u_1} {le : α → α → Bool}
(motive : (s : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Prop)
(s : Batteries.BinomialHeap.Imp.Heap α) (h : Batteries.BinomialHeap.Imp.Heap.WF le n' s),
(∀ (h : Batteries.BinomialHeap.Imp.Heap.WF le n' Batteries.BinomialHeap.Imp... | false |
LinearIsometryEquiv.toLinearEquiv_symm | 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₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | true |
Nat.toArray_ric_eq_cons | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = #[0] ++ (1...=n).toArray | true |
SimpleGraph.Subgraph.IsPerfectMatching.exists_of_isClique_supp | Mathlib.Combinatorics.SimpleGraph.Tutte | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V],
Even (Nat.card V) →
¬G.IsTutteViolator G.universalVerts →
(∀ (K : G.deleteUniversalVerts.coe.ConnectedComponent), G.deleteUniversalVerts.coe.IsClique K.supp) →
∃ M, M.IsPerfectMatching | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_271 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
SimpleGraph.ediam_eq_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G : SimpleGraph α}, G.ediam = ⊤ ↔ ∀ b < ⊤, ∃ u v, b < G.edist u v | true |
List.Forall._unsafe_rec | Mathlib.Data.List.Defs | {α : Type u_1} → (α → Prop) → List α → Prop | false |
Std.DHashMap.Const.get?_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {a : α}, Std.DHashMap.Const.get? ∅ a = none | true |
NormedAddGroup.toBornology._inherited_default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
(dist : E → E → ℝ) →
(∀ (x y : E), dist x y = dist y x) → (∀ (x y z : E), dist x z ≤ dist x y + dist y z) → Bornology E | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Operations | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
... | true |
List.modify_eq_nil_iff | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {i : ℕ} {l : List α}, l.modify i f = [] ↔ l = [] | true |
OrderType.inductionOn₂ | Mathlib.Order.Types.Defs | ∀ {C : OrderType.{u_1} → OrderType.{u_2} → Prop} (o₁ : OrderType.{u_1}) (o₂ : OrderType.{u_2}),
(∀ (α : Type u_1) [inst : LinearOrder α] (β : Type u_2) [inst_1 : LinearOrder β],
C (OrderType.type α) (OrderType.type β)) →
C o₁ o₂ | true |
_private.Mathlib.RingTheory.Localization.Algebra.0.IsLocalization.ker_map._simp_1_2 | Mathlib.RingTheory.Localization.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (s : ↥M),
(IsLocalization.mk' S x s = 0) = ∃ m, ↑m * x = 0 | false |
Submodule.finrank_quotient | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_2} R] [StrongRankCondition R] [Module.Finite R M] {S : Type u_1} [inst_6 : Ring S]
[inst_7 : SMul R S] [inst_8 : Module S M] [inst_9 : IsScalarTower R S M] (N : Submodule S M),
Module.finrank R (M ⧸... | true |
BitVec.toNat_mul_toNat_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.toNat * y.toNat < 2 ^ (w * 2) | true |
Ideal.stabilizerEquiv_symm_apply_smul | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {N : Type u_3}
[inst_3 : Group N] [inst_4 : MulSemiringAction N R] (I : Ideal R) (e : M ≃* N)
(he : ∀ (m : M) (x : R), e m • x = m • x) (n : ↥(MulAction.stabilizer N I)) (x : R),
(I.stabilizerEquiv e he).symm n... | true |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_7 | 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),
CochainComplex.HomComplex.Cochain.ofHom
(CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.... | false |
Lean.Elab.Term.ElabElim.Context | Lean.Elab.App | Type | true |
Lean.Elab.Term.Do.ToTerm.reassignToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax | true |
CategoryTheory.Functor.instCommShift₂IntCochainComplexIntMap₂CochainComplex._proof_4 | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Preadditive C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D]... | false |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_4 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
_private.Init.Data.Nat.Control.0.Nat.forM.loop | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit | true |
Mathlib.Tactic.LinearCombination'.neg_pf | Mathlib.Tactic.LinearCombination' | ∀ {α : Type u_1} {a b : α} [inst : Neg α], a = b → -a = -b | true |
Subgroup.instInfSet | Mathlib.Algebra.Group.Subgroup.Lattice | {G : Type u_1} → [inst : Group G] → InfSet (Subgroup G) | true |
CategoryTheory.Mon.limit_mon_mul | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (hc : CategoryTheory.Limits.I... | true |
Finset.compls_subset_compls._simp_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {s₁ s₂ : Finset α}, (s₁.compls ⊆ s₂.compls) = (s₁ ⊆ s₂) | false |
Set.EqOn.comp_eq | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_7} {f : ι → α} {g₁ g₂ : α → β},
Set.EqOn g₁ g₂ (Set.range f) → g₁ ∘ f = g₂ ∘ f | true |
MeasureTheory.Measure.instMeasurableAdd₂ | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_3} {m : MeasurableSpace α}, MeasurableAdd₂ (MeasureTheory.Measure α) | true |
CategoryTheory.Lax.LaxTrans.homCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Lax.LaxTrans.Hom X Y),
{ as := f.as.vcomp { as := CategoryTheory.Lax.LaxTrans.Modification.id Y }.as } = f | false |
dimH_empty | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X], dimH ∅ = 0 | true |
Int8.reduceMul._regBuiltin.Int8.reduceMul.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.76 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
AlgebraicGeometry.Scheme.Modules.restrictStalkNatIso | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
[inst : AlgebraicGeometry.IsOpenImmersion f] →
(x : ↥X) →
(AlgebraicGeometry.Scheme.Modules.restrictFunctor f).comp
((AlgebraicGeometry.Scheme.Modules.toPresheaf X).comp (TopCat.Presheaf.stalkFunctor Ab x)) ≅
(AlgebraicGeometry.S... | true |
Lagrange.nodal_insert_eq_nodal | Mathlib.LinearAlgebra.Lagrange | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} {s : Finset ι} {v : ι → R} [inst_1 : DecidableEq ι] {i : ι},
i ∉ s → Lagrange.nodal (insert i s) v = (Polynomial.X - Polynomial.C (v i)) * Lagrange.nodal s v | true |
Std.DHashMap.get_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{f : β k → β k} {h : k ∈ m.modify k f}, (m.modify k f).get k h = f (m.get k ⋯) | true |
AddAction.nonempty_orbit | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M α] (a : α), (AddAction.orbit M a).Nonempty | true |
Topology.closure_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr | true |
Lean.Meta.simpEq.match_6 | Mathlib.Lean.Meta.Simp | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((u : Lean.Level) → (α lhs rhs : Lean.Expr) → motive ((((Lean.Expr.const `Eq [u]).app α).app lhs).app rhs)) →
((x : Lean.Expr) → motive x) → motive type | false |
BitVec.shiftLeftZeroExtend._proof_1 | Init.Data.BitVec.Basic | ∀ {w x : ℕ}, x < 2 ^ w → ∀ (m : ℕ), x <<< m < 2 ^ (w + m) | false |
CategoryTheory.MorphismProperty.multiplicativeClosure'.below.id | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure' x → Prop} (x : C),
CategoryTheory.MorphismProperty.multiplicativeClosure'.below ⋯ | true |
LocallyConstant.instCommMonoid | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [CommMonoid Y] → CommMonoid (LocallyConstant X Y) | true |
conjneg_inj | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f g : G → R},
conjneg f = conjneg g ↔ f = g | true |
GenContFract.IntFractPair.stream_zero | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.stream v 0 = some (GenContFract.IntFractPair.of v) | true |
CategoryTheory.Functor.essImage.liftFunctor._proof_1 | Mathlib.CategoryTheory.EssentialImage | ∀ {J : Type u_6} {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(G : CategoryTheory.Functor J D) (F : CategoryTheory.Functor C D) [inst_3 : F.Full] [F.Faithful]
(hG : ∀ (j : J), F.essImage ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.