name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.evaluation._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {x x_1 : C} (f : x ⟶ x_1) ⦃X Y : CategoryTheory.Functor C D⦄
(f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
({ obj := fun F => F.obj x, map := fun {X Y} α => α.app x, map_id := ⋯,... | false |
QPF.Wequiv.abs | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] (a : (QPF.P F).A) (f : (QPF.P F).B a → (QPF.P F).W) (a' : (QPF.P F).A)
(f' : (QPF.P F).B a' → (QPF.P F).W), QPF.abs ⟨a, f⟩ = QPF.abs ⟨a', f'⟩ → QPF.Wequiv (WType.mk a f) (WType.mk a' f') | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
Lean.Parser.Error.mk.sizeOf_spec | Lean.Parser.Types | ∀ (unexpectedTk : Lean.Syntax) (unexpected : String) (expected : List String),
sizeOf { unexpectedTk := unexpectedTk, unexpected := unexpected, expected := expected } =
1 + sizeOf unexpectedTk + sizeOf unexpected + sizeOf expected | true |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.instFullOppositeIdealSheafDataOverSubschemeFunctor._simp_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (h : X = Y),
CategoryTheory.IsIso (CategoryTheory.eqToHom h) = True | false |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.throw_ExceptT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
Set.Icc.coe_nonneg | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] (x : ↑(Set.Icc 0 1)), 0 ≤ ↑x | true |
Matrix.single_apply_of_col_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α]
(i i' : m) {j j' : n}, j ≠ j' → ∀ (a : α), Matrix.single i j a i' j' = 0 | true |
isPreirreducible_singleton | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, IsPreirreducible {x} | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_53 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47 →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_49 → r₀ ≤ r' | false |
continuousOn_stereoToFun | Mathlib.Geometry.Manifold.Instances.Sphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {v : E},
ContinuousOn (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1} | true |
CategoryTheory.Oplax.OplaxTrans.Modification.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Modification η θ} →
{B' : ... | false |
Lean.Data.Trie.empty | Lean.Data.Trie | {α : Type} → Lean.Data.Trie α | true |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.rec | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | {motive : Lean.Meta.Grind.Arith.CommRing.RingM.Context → Sort u} →
((ringId : ℕ) → (checkCoeffDvd : Bool) → motive { ringId := ringId, checkCoeffDvd := checkCoeffDvd }) →
(t : Lean.Meta.Grind.Arith.CommRing.RingM.Context) → motive t | false |
Real.sqrt_inj._simp_1 | Mathlib.Data.Real.Sqrt | ∀ {x y : ℝ}, 0 ≤ x → 0 ≤ y → (√x = √y) = (x = y) | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.performRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} →
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n →
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n →
Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) →
Array ℕ → Array (ℕ × Array ℕ) → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool | true |
Aesop.RuleTacDescr.cases.noConfusion | Aesop.RuleTac.Descr | {P : Sort u} →
{target : Aesop.CasesTarget} →
{md : Lean.Meta.TransparencyMode} →
{isRecursiveType : Bool} →
{ctorNames : Array Aesop.CtorNames} →
{target' : Aesop.CasesTarget} →
{md' : Lean.Meta.TransparencyMode} →
{isRecursiveType' : Bool} →
{cto... | false |
CategoryTheory.ObjectProperty.InheritedFromSource.instMin | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P P' : CategoryTheory.ObjectProperty C)
(Q : CategoryTheory.MorphismProperty C) [P.InheritedFromSource Q] [P'.InheritedFromSource Q],
(P ⊓ P').InheritedFromSource Q | true |
Vector.set | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i < n) Vector.set._auto_1 → Vector α n | true |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.exists_integrable_exp_sq_of_map_rotation_eq_self_of_isProbabilityMeasure._simp_1_2 | Mathlib.Probability.Distributions.Fernique | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
CategoryTheory.Cat.freeRefl_map | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {X Y : CategoryTheory.ReflQuiv} (F : X ⟶ Y),
CategoryTheory.Cat.freeRefl.map F = (CategoryTheory.Cat.freeReflMap F).toCatHom | true |
CategoryTheory.MorphismProperty.equivalenceLeftFractionRel | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
[W.HasLeftCalculusOfFractions] (X Y : C), Equivalence CategoryTheory.MorphismProperty.LeftFractionRel | true |
ConvexSpace.noConfusion | Mathlib.LinearAlgebra.ConvexSpace | {P : Sort u_1} →
{R : Type u} →
{M : Type v} →
{inst : PartialOrder R} →
{inst_1 : Semiring R} →
{inst_2 : IsStrictOrderedRing R} →
{t : ConvexSpace R M} →
{R' : Type u} →
{M' : Type v} →
{inst' : PartialOrder R'} →
... | false |
ValuationSubring.instFieldSubtypeMemTop._proof_19 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (x x_1 : ↥⊤), ↑(x - x_1) = ↑(x - x_1) | false |
instInvInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : CommGroup α] → [inst_1 : PartialOrder α] → [IsOrderedMonoid α] → Inv (Interval α) | true |
Lean.Lsp.TextDocumentSyncOptions.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentSyncOptions → Sort u} →
((openClose : Bool) →
(change : Lean.Lsp.TextDocumentSyncKind) →
(willSave willSaveWaitUntil : Bool) →
(save? : Option Lean.Lsp.SaveOptions) →
motive
{ openClose := openClose, change := change, willSave := willSav... | false |
Std.Internal.List.containsKey_iff_exists | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a l = true ↔ ∃ a' ∈ Std.Internal.List.keys l, (a == a') = true | true |
QuadraticModuleCat.instMonoidalCategory.tensorHom | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} →
[inst : CommRing R] →
[inst_1 : Invertible 2] →
{W X Y Z : QuadraticModuleCat R} →
(W ⟶ X) →
(Y ⟶ Z) →
(QuadraticModuleCat.instMonoidalCategory.tensorObj W Y ⟶
QuadraticModuleCat.instMonoidalCategory.tensorObj X Z) | true |
CategoryTheory.Equalizer.Sieve.SecondObj.ext | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))} {X : C}
{S : CategoryTheory.Sieve X} (z₁ z₂ : CategoryTheory.Equalizer.Sieve.SecondObj P S),
(∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.o... | true |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.coeff_mul_prod_one_sub_of_lt_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
NumberField.Units.instFintypeSubtypeUnitsRingOfIntegersMemSubgroupTorsion._proof_1 | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Finite ↑↑(NumberField.Units.torsion K) | false |
ZFSet.instReflSubset | Mathlib.SetTheory.ZFC.Basic | Std.Refl fun x1 x2 => x1 ⊆ x2 | true |
Ideal.mulQuot | Mathlib.RingTheory.OrderOfVanishing | {R : Type u_1} → [inst : CommRing R] → (a : R) → (I : Ideal R) → R ⧸ I →ₗ[R] R ⧸ a • I | true |
Filter.comap_lift_eq | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : γ → β},
Filter.comap m (f.lift g) = f.lift (Filter.comap m ∘ g) | true |
Filter.Germ.const_lt_iff | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : Preorder β] {x y : β}, ↑x < ↑y ↔ x < y | true |
FormalMultilinearSeries.rightInv._proof_16 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.newCone_pt | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra}
(c : CategoryTheory.Limits.Cone (D.comp T.forget)), (CategoryTheory.Comonad.ForgetCreatesLimits'.newCone c).pt = c.pt | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeries._simp_1_1 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | false |
Lean.Grind.Linarith.Poly.NonnegCoeffs.brecOn | Init.Grind.Module.NatModuleNorm | ∀ {motive : (a : Lean.Grind.Linarith.Poly) → a.NonnegCoeffs → Prop} {a : Lean.Grind.Linarith.Poly} (t : a.NonnegCoeffs),
(∀ (a : Lean.Grind.Linarith.Poly) (t : a.NonnegCoeffs), Lean.Grind.Linarith.Poly.NonnegCoeffs.below t → motive a t) →
motive a t | true |
MeasureTheory.lintegral_prod_mul | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {f : α → ENNReal} {g : β → ENNReal},
AEMeasurable f μ →
AEMeasurable g ν → ∫⁻ (z : α × β), f z.1 * g z.2 ∂μ.prod ν = (∫⁻ (x : α), f x ∂μ) ... | true |
Asymptotics.isBigO_const_mul_self | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] (c : R) (f : α → R) (l : Filter α),
(fun x => c * f x) =O[l] f | true |
Batteries.Tactic.Lint.LintVerbosity._sizeOf_1 | Batteries.Tactic.Lint.Frontend | Batteries.Tactic.Lint.LintVerbosity → ℕ | false |
_private.Mathlib.RingTheory.Ideal.NatInt.0.Nat.one_mem_span_iff._simp_1_4 | Mathlib.RingTheory.Ideal.NatInt | {1}ᶜ = ↑(IsLocalRing.maximalIdeal ℕ) | false |
CategoryTheory.Lax.LaxTrans.LaxFunctor.bicategory_associator_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{x x_1 x_2 : CategoryTheory.LaxFunctor B C} (x_3 : CategoryTheory.LaxFunctor B C) (η : x ⟶ x_1) (θ : x_1 ⟶ x_2)
(ι : x_2 ⟶ x_3) (a : B),
(CategoryTheory.Bicategory.associator η θ ι).inv.as.app a =
(Catego... | true |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW._simp_1_3 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
completeBipartiteGraph | Mathlib.Combinatorics.SimpleGraph.Basic | (V : Type u_1) → (W : Type u_2) → SimpleGraph (V ⊕ W) | true |
Int.neg_add_le_right_of_le_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, a ≤ b + c → -c + a ≤ b | true |
_private.Init.Data.Array.Basic.0.Array.mapM.map._unary._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_2} {β : Type u_1} (as : Array α) (i : ℕ) (bs : Array β),
i < as.size →
∀ (__do_lift : β),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i bs => as.size - i) ⟨i + 1, bs.push __do_lift⟩
⟨i, bs⟩ | false |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.splitter | Init.Data.Option.Monadic | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((r : β) → motive (ForInStep.done r)) → ((r : β) → motive (ForInStep.yield r)) → motive __do_lift | true |
Aesop.PostponedSafeRule.ctorIdx | Aesop.Tree.UnsafeQueue | Aesop.PostponedSafeRule → ℕ | false |
_private.Mathlib.Topology.Order.LeftRightLim.0.tendsto_atTop_of_mapClusterPt._simp_1_1 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
Mathlib.Tactic.IntervalCases.Bound.lt.injEq | Mathlib.Tactic.IntervalCases | ∀ (n n_1 : ℤ), (Mathlib.Tactic.IntervalCases.Bound.lt n = Mathlib.Tactic.IntervalCases.Bound.lt n_1) = (n = n_1) | true |
CategoryTheory.Grothendieck.Hom.noConfusionType | Mathlib.CategoryTheory.Grothendieck | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C CategoryTheory.Cat} →
{X Y : CategoryTheory.Grothendieck F} →
X.Hom Y →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{F' : Category... | false |
_private.Mathlib.RingTheory.Filtration.0.Ideal.Filtration.Stable.exists_pow_smul_eq._proof_1_1 | Mathlib.RingTheory.Filtration | ∀ (n₀ n : ℕ), n₀ ≤ n₀ + n | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._proof_1 | Init.Data.Nat.Power2.Basic | ∀ power > 0, 0 < power * 2 | false |
WithZero.instCoeTC.eq_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u}, WithZero.instCoeTC = { coe := WithZero.coe } | true |
MeasureTheory.eLpNorm_le_eLpNorm_mul_eLpNorm_of_nnnorm | Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {m : MeasurableSpace α} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.Measure α} {f : α → E} {g : α → F}
{p q r : ENNReal},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AE... | true |
AffineSubspace.mem_perpBisector_iff_inner_eq_inner | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ inner ℝ (c -ᵥ p₁) (p₂ -ᵥ p₁) = inner ℝ (c -ᵥ p₂) (p₁ -ᵥ p₂) | true |
Part.some_sdiff_some | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : α), Part.some a \ Part.some b = Part.some (a \ b) | true |
AlgCat.instMonoidalCategory.tensorHom._proof_1 | Mathlib.Algebra.Category.AlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] {W : AlgCat R}, IsScalarTower R R ↑W | false |
_private.Mathlib.Order.CountableDenseLinearOrder.0.Order.exists_orderEmbedding_insert._simp_1_3 | Mathlib.Order.CountableDenseLinearOrder | ∀ {α : Type u_1} (s : Finset α) (x : ↥s), (x ∈ s.attach) = True | false |
Sum.bnot_isRight | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (x : α ⊕ β), (!x.isRight) = x.isLeft | true |
Valuation.norm._proof_1 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀],
MonoidWithZeroHomClass (Valuation L Γ₀) L Γ₀ | false |
Std.DTreeMap.Raw.get!.congr_simp | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.LawfulEqCmp cmp]
(t t_1 : Std.DTreeMap.Raw α β cmp), t = t_1 → ∀ (a : α) [inst_1 : Inhabited (β a)], t.get! a = t_1.get! a | true |
_private.Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral.0._aux_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral___macroRules__private_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral_0_term𝓟_1_1 | Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral | Lean.Macro | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Constructions.0.sphere_prod._simp_1_5 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b = c) = (a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b) | false |
Batteries.Tactic.TransRelation.implies.elim | Batteries.Tactic.Trans | {motive : Batteries.Tactic.TransRelation → Sort u} →
(t : Batteries.Tactic.TransRelation) →
t.ctorIdx = 1 →
((name : Lean.Name) → (bi : Lean.BinderInfo) → motive (Batteries.Tactic.TransRelation.implies name bi)) → motive t | false |
IncidenceAlgebra.lambda_apply | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_2) {α : Type u_5} [inst : Zero 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : DecidableRel fun x1 x2 => x1 ⩿ x2] (a b : α), (IncidenceAlgebra.lambda 𝕜) a b = if a ⩿ b then 1 else 0 | true |
_private.Lean.ToExpr.0.Lean.Name.toExprAux.isSimple._unsafe_rec | Lean.ToExpr | Lean.Name → ℕ → Bool | false |
Valuation.RankOne.toRankLeOne | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : Ring R} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} → {v : Valuation R Γ₀} → [self : v.RankOne] → v.RankLeOne | true |
Ordinal.lt_add_iff | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b c : Ordinal.{u_4}}, c ≠ 0 → (a < b + c ↔ ∃ d < c, a ≤ b + d) | true |
FreeMonoid.count_apply | Mathlib.Algebra.FreeMonoid.Count | ∀ {α : Type u_1} [inst : DecidableEq α] (x : α) (l : FreeAddMonoid α),
(FreeMonoid.count x) l = Multiplicative.ofAdd (List.count x (FreeAddMonoid.toList l)) | true |
AddGroupWithOne.noConfusionType | Mathlib.Data.Int.Cast.Defs | Sort u_1 → {R : Type u} → AddGroupWithOne R → {R' : Type u} → AddGroupWithOne R' → Sort u_1 | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Complex.cosh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.cosh ↑x).im = 0 | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory._proof_4 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) (J : Type u_1) [inst_1 : CategoryTheory.Category.{u_4, u_1} J]
⦃X Y : CategoryTheory.Arrow (CategoryTheory.Functor J C)⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.... | false |
Std.HashMap.getKey_eq_getKeyD | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α} {h' : a ∈ m}, m.getKey a h' = m.getKeyD a fallback | true |
Fin.orderPred_zero | Mathlib.Data.Fin.SuccPredOrder | ∀ (n : ℕ), Order.pred 0 = 0 | true |
CoxeterMatrix.recOn | Mathlib.GroupTheory.Coxeter.Matrix | {B : Type u_1} →
{motive : CoxeterMatrix B → Sort u} →
(t : CoxeterMatrix B) →
((M : Matrix B B ℕ) →
(isSymm : M.IsSymm) →
(diagonal : ∀ (i : B), M i i = 1) →
(off_diagonal : ∀ (i i' : B), i ≠ i' → M i i' ≠ 1) →
motive { M := M, isSymm := isSymm, diagonal ... | false |
CategoryTheory.Mat_.instPreadditive._proof_2 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N K : CategoryTheory.Mat_ C) (f : M ⟶ N) (g g' : N ⟶ K),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g' | false |
Std.CloseableChannel.Flavors._sizeOf_1 | Std.Sync.Channel | {α : Type} → [SizeOf α] → Std.CloseableChannel.Flavors α → ℕ | false |
Matrix._aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Defs___unexpand_Matrix_GeneralLinearGroup_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.isLUB_range_ωSup._simp_1_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
Array.map_eq_append_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys zs : Array β} {f : α → β},
Array.map f xs = ys ++ zs ↔ ∃ as bs, xs = as ++ bs ∧ Array.map f as = ys ∧ Array.map f bs = zs | true |
MeasureTheory.eLpNormLESNormFDerivOfEqInnerConst.eq_1 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ {E : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
[inst_3 : BorelSpace E] [inst_4 : FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [inst_5 : μ.IsAddHaarMeasure]
(p : ℝ),
MeasureTheory.eLpNormLESNormFDerivOfEqInnerConst μ p =
MeasureTheory.eLpNormLESNo... | true |
CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F → Sort u} →
(t : CategoryThe... | false |
instDecidableStrictAntiOnOfForallForallMemSetForallForallForallLt | Mathlib.Order.Monotone.Defs | {α : Type u} →
{β : Type v} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{f : α → β} → {s : Set α} → [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a < b → f b < f a)] → Decidable (StrictAntiOn f s) | true |
Std.TreeMap.getElem?_insertMany_list.match_1 | Std.Data.TreeMap.Lemmas | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | false |
MeasureTheory.memLp_congr_norm | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {E : Type u_4} {F : Type u_5} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : α → E} {g : α → F},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ →
(∀ᵐ (a : α) ∂μ, ‖f a‖... | true |
Filter.iSup_inf_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {ι : Sort x} (f : ι → Filter α) (s : Set α),
⨆ i, f i ⊓ Filter.principal s = (⨆ i, f i) ⊓ Filter.principal s | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.LinearMap.iSupIndep_map.match_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u_4} {R : Type u_2} {M : Type u_3} {M' : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M') {m : ι → Submodule R M}
(i : ι) (x : M) (motive : f x ∈ ↑(Submodule.map f (⨆ i_1, ⨆ (_ : i_1 ≠ i), m i_1)) → Prop)
... | false |
Quiver.Path.rec.eq._@.Mathlib.Combinatorics.Quiver.Path.3963176020._hygCtx._hyg.4 | Mathlib.Combinatorics.Quiver.Path | @Quiver.Path.rec = @Quiver.Path.rec✝ | false |
Units.ctorIdx | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → {inst : Monoid α} → αˣ → ℕ | false |
Aesop.UnsafeQueueEntry.unsafeRule.elim | Aesop.Tree.UnsafeQueue | {motive : Aesop.UnsafeQueueEntry → Sort u} →
(t : Aesop.UnsafeQueueEntry) →
t.ctorIdx = 0 →
((r : Aesop.IndexMatchResult Aesop.UnsafeRule) → motive (Aesop.UnsafeQueueEntry.unsafeRule r)) → motive t | false |
Function.Embedding.toEmbedding_equivOfFiniteSelfEmbedding | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} [inst : Finite α] (e : α ↪ α), e.equivOfFiniteSelfEmbedding.toEmbedding = e | true |
Interval.length.match_1 | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_1} →
[inst : PartialOrder α] →
(motive : Interval α → Sort u_2) →
(x : Interval α) → (Unit → motive none) → ((s : NonemptyInterval α) → motive (some s)) → motive x | false |
Std.TreeMap.Raw.foldl | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap.Raw α β cmp → δ | true |
CategoryTheory.InjectiveResolution.ι | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} → (self : CategoryTheory.InjectiveResolution Z) → (CochainComplex.single₀ C).obj Z ⟶ self.cocomplex | true |
Ordinal.veblen_right_strictMono | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), StrictMono (Ordinal.veblen o) | true |
ModuleFilterBasis.instInhabitedOfDiscreteTopology | Mathlib.Topology.Algebra.FilterBasis | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → [DiscreteTopology R] → Inhabited (ModuleFilterBasis R M) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.