name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddMonoid.End.instOne.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M], AddMonoid.End.instOne M = { one := AddMonoidHom.id M } | true |
Mathlib.Tactic.GCongr.imp_trans | Mathlib.Tactic.GCongr.CoreAttrs | ∀ {a b c : Prop}, (a → b) → (b → c) → a → c | true |
CategoryTheory.Functor.curry₃ObjProdComp_hom_app_app_app | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_4} {D₁ : Type u_6} {D₂ : Type u_7} {D₃ : Type u_8} {E : Type u_9}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_4} C₃] [inst_3 : CategoryTheory.Category.{v_6, u_6} D₁]
[inst_4... | true |
WithTop.Ico_coe_top | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a : α),
Finset.Ico ↑a ⊤ = Finset.map Function.Embedding.some (Finset.Ici a) | true |
_private.Init.Data.Array.MapIdx.0.Array.mapIdx_eq_push_iff._simp_1_2 | Init.Data.Array.MapIdx | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Nat.Primrec.prec | Mathlib.Computability.Primrec.Basic | ∀ {f g : ℕ → ℕ},
Nat.Primrec f →
Nat.Primrec g → Nat.Primrec (Nat.unpaired fun z n => Nat.rec (f z) (fun y IH => g (Nat.pair z (Nat.pair y IH))) n) | true |
Lean.SubExpr.bindingBody! | Lean.SubExpr | Lean.SubExpr → Lean.SubExpr | true |
Localization.exists_awayMap_injective_of_localRingHom_injective | Mathlib.RingTheory.Unramified.LocalRing | ∀ {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] {q : Ideal S} [inst_4 : q.IsPrime],
(RingHom.ker (algebraMap R S)).FG →
∀ [inst_5 : q.LiesOver p],
Function.Injective ⇑(Localization.localRingHom p q (algebraMap R S) ⋯) →
... | true |
CategoryTheory.associator_inv_apply_2 | Mathlib.CategoryTheory.Monoidal.Types.Basic | ∀ {X Y Z : Type u}
{x : CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)},
((CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv x).2 = x.2.2 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.inter_congr._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Lean.Elab.Term.instInhabitedPostponeBehavior.default | Lean.Elab.SyntheticMVars | Lean.Elab.Term.PostponeBehavior | true |
Matrix.IsHermitian.eigenvectorUnitary_apply | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(hA : A.IsHermitian) (i j : n), ↑hA.eigenvectorUnitary i j = (hA.eigenvectorBasis j).ofLp i | true |
Lean.MetavarContext.LevelMVarToParam.instMonadCacheExprStructEqExprM | Lean.MetavarContext | Lean.MonadCache Lean.ExprStructEq Lean.Expr Lean.MetavarContext.LevelMVarToParam.M | true |
FreeMonoid.notMem_one | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {m : α}, m ∉ 1 | true |
_private.Mathlib.Tactic.Linarith.Verification.0.Mathlib.Tactic.Linarith.mkLTZeroProof.step.match_3 | Mathlib.Tactic.Linarith.Verification | (motive : Mathlib.Ineq × Lean.Expr → Sort u_1) →
(__discr : Mathlib.Ineq × Lean.Expr) → ((iq : Mathlib.Ineq) → (h' : Lean.Expr) → motive (iq, h')) → motive __discr | false |
RootPairing.IsValuedIn.exists_value | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} {inst : CommRing R} {inst_1 : AddCommGroup M}
{inst_2 : Module R M} {inst_3 : AddCommGroup N} {inst_4 : Module R N} {P : RootPairing ι R M N} {S : Type u_6}
{inst_5 : CommRing S} {inst_6 : Algebra S R} [self : P.IsValuedIn S] (i j : ι),
∃ s, (algebraMa... | true |
Finset.sum_indicator_eq_sum_filter | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {κ : Type u_2} {β : Type u_4} [inst : AddCommMonoid β] (s : Finset ι) (f : ι → κ → β) (t : ι → Set κ)
(g : ι → κ) [inst_1 : DecidablePred fun i => g i ∈ t i],
∑ i ∈ s, (t i).indicator (f i) (g i) = ∑ i ∈ s with g i ∈ t i, f i (g i) | true |
Std.Internal.List.minKeyD_insertEntryIfNew_of_isEmpty | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α] {k : α} {v : β k}
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = true →
∀ {fallback : α}, Std.Internal.List.minKeyD (Std.Internal.List.insertEntryIfNew k v l) fallback = k | true |
charZero_of_injective_ringHom | Mathlib.Algebra.CharP.Algebra | ∀ {R : Type u_1} {A : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring A] {f : R →+* A},
Function.Injective ⇑f → ∀ [CharZero R], CharZero A | true |
CategoryTheory.ShortComplex.HomologyMapData.ofIsLimitKernelFork | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(φ : S₁ ⟶ S₂) →
(hf₁ : S₁.f = 0) →
(c₁ : CategoryTheory.Limits.KernelFork S₁.g) →
(hc₁ : CategoryTheory.Limit... | true |
IntermediateField.LinearDisjoint.isField_of_forall | Mathlib.FieldTheory.LinearDisjoint | ∀ (F : Type u) [inst : Field F] (A : Type v) [inst_1 : Field A] (B : Type w) [inst_2 : Field B] [inst_3 : Algebra F A]
[inst_4 : Algebra F B],
(∀ (K : Type (max v w)) [inst_5 : Field K] [inst_6 : Algebra F K] (fa : A →ₐ[F] K) (fb : B →ₐ[F] K),
fa.fieldRange.LinearDisjoint ↥fb.fieldRange) →
IsField (Tensor... | true |
_private.Mathlib.Tactic.DeclarationNames.0.Mathlib.Linter.getNamesFrom.match_1 | Mathlib.Tactic.DeclarationNames | (motive : Lean.Name × Lean.DeclarationRanges → Sort u_1) →
(x : Lean.Name × Lean.DeclarationRanges) →
((nm : Lean.Name) → (rgs : Lean.DeclarationRanges) → motive (nm, rgs)) → motive x | false |
SimpleGraph.Walk.ofSupport._unsafe_rec | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} →
{G : SimpleGraph V} → (l : List V) → (hne : l ≠ []) → List.IsChain G.Adj l → G.Walk (l.head hne) (l.getLast hne) | false |
WithCStarModule.neg_snd | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_3} {F : Type u_4} (x : WithCStarModule A (E × F)) [inst : AddCommGroup E]
[inst_1 : AddCommGroup F], (-x).2 = -x.2 | true |
Function.locallyFinsuppWithin.noConfusionType | Mathlib.Topology.LocallyFinsupp | Sort u →
{X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} →
{Y : Type u_2} →
[inst_1 : Zero Y] →
Function.locallyFinsuppWithin U Y →
{X' : Type u_1} →
[inst' : TopologicalSpace X'] →
{U' : Set X'} → {Y' : Type u_2} → [in... | false |
SimpleGraph.CliqueFree | Mathlib.Combinatorics.SimpleGraph.Clique | {α : Type u_1} → SimpleGraph α → ℕ → Prop | true |
WithCStarModule.inner_def | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] (x y : A),
inner A x y = y * star x | true |
UInt16.decEq.match_1 | Init.Prelude | (motive : UInt16 → UInt16 → Sort u_1) →
(a b : UInt16) → ((n m : BitVec 16) → motive { toBitVec := n } { toBitVec := m }) → motive a b | false |
DirectLimit.instMonoid._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → Monoid (G i)]
[∀ (i j : ι) (h : i ≤ j), MonoidHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j), MulHomClass (T h) (G i) (G j) | false |
WeierstrassCurve.preΨ'_four | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R), W.preΨ' 4 = W.preΨ₄ | true |
Units.mulArchimedean_iff | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero G₀], MulArchimedean G₀ˣ ↔ MulArchimedean G₀ | true |
Finset.mulConst_inv_right | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G), A.mulConst B⁻¹ = A.divConst B | true |
CategoryTheory.Limits.PullbackCone.opUnopIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
(c : CategoryTheory.Limits.PullbackCone f g),
c.op.unop.fst = CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl c.op.unop.pt).hom c.fst | false |
Module.length_of_free | Mathlib.RingTheory.Length | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Free R M],
Module.length R M = Cardinal.toENat (Module.rank R M) * Module.length R R | true |
Quiver.Total.hom | Mathlib.Combinatorics.Quiver.Subquiver | {V : Type u} → [inst : Quiver V] → (self : Quiver.Total V) → self.left ⟶ self.right | true |
CategoryTheory.ShortComplex.HomotopyEquiv.symm_homotopyHomInvId | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁.HomotopyEquiv S₂), e.symm.homotopyHomInvId = e.homotopyInvHomId | true |
_private.Mathlib.Data.Set.Insert.0.Set.insert_union_distrib._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} (a : α) (s t : Set α), insert a (s ∪ t) = insert a s ∪ insert a t | false |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.hasSubst_iff_hasEval_of_discreteTopology._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {S : Type u_3} [inst : CommRing S] [inst_1 : TopologicalSpace S] (a : σ → S),
MvPowerSeries.HasEval a = ((∀ (s : σ), IsTopologicallyNilpotent (a s)) ∧ Filter.Tendsto a Filter.cofinite (nhds 0)) | false |
one_lt_div' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LT α] [MulRightStrictMono α] {a b : α}, 1 < a / b ↔ b < a | true |
Set.hasSeparatingCover_empty_left | Mathlib.Topology.Separation.SeparatedNhds | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : Set X), HasSeparatingCover ∅ s | true |
SimpleGraph.IsFiveWheelLike.not_colorable_succ | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {s : Finset α} {G : SimpleGraph α} {r k : ℕ} [inst : DecidableEq α] {v w₁ w₂ : α} {t : Finset α},
G.IsFiveWheelLike r k v w₁ w₂ s t → ¬G.Colorable (r + 1) | true |
_private.Lean.PrettyPrinter.Delaborator.FieldNotation.0.Lean.PrettyPrinter.Delaborator.fieldNotationCandidate?.match_3 | Lean.PrettyPrinter.Delaborator.FieldNotation | (motive : DoResultPR Unit (Lean.Name × ℕ) PUnit.{1} → Sort u_1) →
(r : DoResultPR Unit (Lean.Name × ℕ) PUnit.{1}) →
((a : Unit) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Lean.Name × ℕ) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | false |
DerivedCategory.triangleOfSES_distinguished | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (hS : S.ShortExact),
DerivedCategory.triangleOfSES hS ∈ CategoryTheory.Pretriangulated.distinguishedTriangles | true |
Lean.Elab.TerminationMeasure.mk.inj | Lean.Elab.PreDefinition.TerminationMeasure | ∀ {ref : Lean.Syntax} {structural : Bool} {fn : Lean.Expr} {ref_1 : Lean.Syntax} {structural_1 : Bool}
{fn_1 : Lean.Expr},
{ ref := ref, structural := structural, fn := fn } = { ref := ref_1, structural := structural_1, fn := fn_1 } →
ref = ref_1 ∧ structural = structural_1 ∧ fn = fn_1 | true |
IsLeftRegular.mul_eq_one_symm | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : Monoid M] {a b : M}, IsLeftRegular a → a * b = 1 → b * a = 1 | true |
OrthonormalBasis._sizeOf_inst | Mathlib.Analysis.InnerProductSpace.PiL2 | (ι : Type u_1) →
(𝕜 : Type u_3) →
{inst : RCLike 𝕜} →
(E : Type u_4) →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : InnerProductSpace 𝕜 E} →
{inst_3 : Fintype ι} → [SizeOf ι] → [SizeOf 𝕜] → [SizeOf E] → SizeOf (OrthonormalBasis ι 𝕜 E) | false |
BddLat.dual._proof_1 | Mathlib.Order.Category.BddLat | ∀ (X : BddLat),
BddLat.ofHom (BoundedLatticeHom.dual (BddLat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id (BddLat.of (↑X.toLat)ᵒᵈ) | false |
Inv.casesOn | Init.Prelude | {α : Type u} → {motive : Inv α → Sort u_1} → (t : Inv α) → ((inv : α → α) → motive { inv := inv }) → motive t | false |
Mathlib.Meta.FunProp.lambdaTheoremsExt | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremsExt | true |
Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go._unary._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker | ∀ {n : ℕ} (proof : Array Std.Tactic.BVDecide.LRAT.IntAction) (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n),
∀ idx < proof.size,
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun f idx => proof.size - idx) ⟨f, idx + 1⟩ ⟨f, idx⟩ | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyCell_eq_apply_toListModel._simp_1_6 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | false |
ModuleCat.ExtendRestrictScalarsAdj.Counit.map | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
(f : R →+* S) → {Y : ModuleCat S} → ((ModuleCat.restrictScalars f).comp (ModuleCat.extendScalars f)).obj Y ⟶ Y | true |
Finset.card_eq_sum_card_image | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : DecidableEq M] (f : ι → M) (s : Finset ι),
s.card = ∑ b ∈ Finset.image f s, {a ∈ s | f a = b}.card | true |
Module.Basis.linearIndependent_coord._simp_1 | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] {R : Type u_7} [inst_1 : CommSemiring R] [inst_2 : Module R M]
(b : Module.Basis ι R M), LinearIndependent R b.coord = True | false |
Metric.externalCoveringNumber_eq_zero._simp_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal},
(Metric.externalCoveringNumber ε A = 0) = (A = ∅) | false |
Lean.Meta.LibrarySearch.DeclMod.none.sizeOf_spec | Lean.Meta.Tactic.LibrarySearch | sizeOf Lean.Meta.LibrarySearch.DeclMod.none = 1 | true |
Aesop.Tree | Aesop.Tree.TreeM | Type | true |
Substring.beq | Init.Data.String.Substring | Substring.Raw → Substring.Raw → Bool | true |
Int64.zero_div | Init.Data.SInt.Lemmas | ∀ {a : Int64}, 0 / a = 0 | true |
Lean.Elab.Command.elabCommand._unsafe_rec | Lean.Elab.Command | Lean.Syntax → Lean.Elab.Command.CommandElabM Unit | false |
Nat.pred_mul_geom_sum_le | Mathlib.Algebra.Order.Ring.GeomSum | ∀ (a b n : ℕ), (b - 1) * ∑ i ∈ Finset.range n.succ, a / b ^ i ≤ a * b - a / b ^ n | true |
CategoryTheory.FreeBicategory.Hom.of.inj | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} {inst : Quiver B} {a b : B} {f f_1 : a ⟶ b},
CategoryTheory.FreeBicategory.Hom.of f = CategoryTheory.FreeBicategory.Hom.of f_1 → f = f_1 | true |
Lean.Parser.Term.dbgTrace | Lean.Parser.Term | Lean.Parser.Parser | true |
CuspForm.instNeg | Mathlib.NumberTheory.ModularForms.Basic | {Γ : Subgroup (GL (Fin 2) ℝ)} → {k : ℤ} → Neg (CuspForm Γ k) | true |
Tactic.NormNum.evalNNRealSqrt | Mathlib.Tactic.NormNum.RealSqrt | Mathlib.Meta.NormNum.NormNumExt | true |
_private.Init.Grind.Ordered.Linarith.0.Lean.Grind.Linarith.Expr.denote.match_1.eq_2 | Init.Grind.Ordered.Linarith | ∀ (motive : Lean.Grind.Linarith.Expr → Sort u_1) (v : Lean.Grind.Linarith.Var)
(h_1 : Unit → motive Lean.Grind.Linarith.Expr.zero)
(h_2 : (v : Lean.Grind.Linarith.Var) → motive (Lean.Grind.Linarith.Expr.var v))
(h_3 : (a b : Lean.Grind.Linarith.Expr) → motive (a.add b))
(h_4 : (a b : Lean.Grind.Linarith.Expr) →... | true |
TopModuleCat.mk.noConfusion | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | {R : Type u} →
{inst : Ring R} →
{inst_1 : TopologicalSpace R} →
{P : Sort u_1} →
{toModuleCat : ModuleCat R} →
{topologicalSpace : TopologicalSpace ↑toModuleCat} →
{isTopologicalAddGroup : IsTopologicalAddGroup ↑toModuleCat} →
{continuousSMul : ContinuousSMul R ↑... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_minKey?_modify_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
_private.Mathlib.Order.Filter.Finite.0.Filter.mem_biInf_principal._simp_1_2 | Mathlib.Order.Filter.Finite | ∀ {α : Type u_1} {s t : Set α}, (s ∈ Filter.principal t) = (t ⊆ s) | false |
MeasureTheory.fundamentalInterior_smul | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {H : Type u_2} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] (s : Set α) [inst_2 : Group H]
[inst_3 : MulAction H α] [SMulCommClass H G α] (g : H),
MeasureTheory.fundamentalInterior G (g • s) = g • MeasureTheory.fundamentalInterior G s | true |
Std.DTreeMap.Internal.Impl.balancedAtRoot_one_two | Std.Data.DTreeMap.Internal.Balanced | Std.DTreeMap.Internal.Impl.BalancedAtRoot 1 2 | true |
OneHom.coe_copy | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {x : One M} {x_1 : One N} (f : OneHom M N) (f' : M → N) (h : f' = ⇑f),
⇑(f.copy f' h) = f' | true |
_private.Mathlib.Tactic.Order.0.Mathlib.Tactic.Order.updateGraphWithNltInfSup.match_12 | Mathlib.Tactic.Order | (nltFacts : Array Mathlib.Tactic.Order.AtomicFact) →
(motive : MProd Bool (MProd Mathlib.Tactic.Order.Graph (Vector Bool nltFacts.size)) → Sort u_1) →
(r : MProd Bool (MProd Mathlib.Tactic.Order.Graph (Vector Bool nltFacts.size))) →
((changed : Bool) →
(g : Mathlib.Tactic.Order.Graph) →
... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRatUnits._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n),
f.ratUnits = #[] ∧ f.assignments.size = n →
∀ (units : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(li : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), ↑⟨↑li, ⋯⟩ < (f.insertRatUnits units).1.assignments.size | false |
Std.Broadcast.Receiver.recOn | Std.Sync.Broadcast | {α : Type} →
{motive : Std.Broadcast.Receiver α → Sort u} →
(t : Std.Broadcast.Receiver α) → ((inner : Std.Bounded.Receiver✝ α) → motive { inner := inner }) → motive t | false |
AddOpposite.instSemifield | Mathlib.Algebra.Field.Opposite | {α : Type u_1} → [Semifield α] → Semifield αᵃᵒᵖ | true |
FirstOrder.Language.Substructure.fg_iff_finite | Mathlib.ModelTheory.FinitelyGenerated | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] [L.IsRelational] {S : L.Substructure M},
S.FG ↔ Finite ↥S | true |
Lean.Meta.Grind.AC.DiseqCnstr.casesOn | Lean.Meta.Tactic.Grind.AC.Types | {motive_1 : Lean.Meta.Grind.AC.DiseqCnstr → Sort u} →
(t : Lean.Meta.Grind.AC.DiseqCnstr) →
((lhs rhs : Lean.Grind.AC.Seq) →
(h : Lean.Meta.Grind.AC.DiseqCnstrProof) → motive_1 { lhs := lhs, rhs := rhs, h := h }) →
motive_1 t | false |
AlgebraicGeometry.Scheme.Cover.locallyDirectedPullbackCover.eq_1 | Mathlib.AlgebraicGeometry.Normalization | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
[inst : P.IsStableUnderBaseChange] (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst_1 : CategoryTheory.Category.{v_2, u_1} 𝒰.I₀] [inst_2 : 𝒰.LocallyDirected] {Y : AlgebraicGeometry... | true |
Mathlib.Tactic.Module.NF.algebraMap.eq_1 | Mathlib.Tactic.Module | ∀ {S : Type u_1} (R : Type u_2) {M : Type u_3} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : Algebra S R]
(l : Mathlib.Tactic.Module.NF S M),
Mathlib.Tactic.Module.NF.algebraMap R l =
List.map
(fun x =>
match x with
| (s, x) => ((algebraMap S R) s, x))
l | true |
Matroid.IsBasis.subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis I X → X ⊆ M.E | true |
Finset.image₂_left_identity | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {γ : Type u_5} [inst : DecidableEq γ] {f : α → γ → γ} {a : α},
(∀ (b : γ), f a b = b) → ∀ (t : Finset γ), Finset.image₂ f {a} t = t | true |
LinearEquiv.conj._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁' : Type u_1} {R₂' : Type u_2} [inst : CommSemiring R₁'] [inst_1 : CommSemiring R₂'] {σ₁'₂' : R₁' →+* R₂'},
RingHomCompTriple (RingHom.id R₁') σ₁'₂' σ₁'₂' | false |
BitVec.udiv_eq_zero_iff_eq_zero_or_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x / y = 0#w ↔ y = 0#w ∨ x < y | true |
Std.Iter.finitelyManySkips! | Init.Data.Iterators.Basic | {α β : Type w} → [inst : Std.Iterator α Id β] → Std.Iter β → Std.IterM.TerminationMeasures.Productive α Id | true |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.Const.get_alter._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
QuotientGroup.instSeminormedCommGroup._proof_6 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] (S : Subgroup M), IsTopologicalGroup (M ⧸ S) | false |
_private.Mathlib.Data.Set.Defs.0.Set.instLawfulFunctor.match_5 | Mathlib.Data.Set.Defs | ∀ {α β γ : Type u_1} (g : α → β) (h : β → γ) (x : Set α) (c : γ) (motive : (h <$> g <$> x) c → Prop)
(x_1 : (h <$> g <$> x) c), (∀ (w : β) (a : α) (h₁ : a ∈ x) (h₂ : g a = w) (h₃ : h w = c), motive ⋯) → motive x_1 | false |
Nat.sub_dvd_pow_sub_pow | Mathlib.Algebra.Ring.GeomSum | ∀ (x y n : ℕ), x - y ∣ x ^ n - y ^ n | true |
_private.Mathlib.Tactic.GCongr.Core.0.Lean.MVarId.applyWithArity.match_1 | Mathlib.Tactic.GCongr.Core | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (r : Lean.Expr) → motive (fst, fst_1, r)) →
motive __discr | false |
OrderIso.symm_mk | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃ β)
(map_rel_iff' : ∀ {a b : α}, e a ≤ e b ↔ a ≤ b),
OrderIso.symm { toEquiv := e, map_rel_iff' := map_rel_iff' } = { toEquiv := e.symm, map_rel_iff' := ⋯ } | true |
Nat.ofNat_pos'._simp_1 | Mathlib.Data.Nat.Cast.Order.Ring | ∀ {α : Type u_2} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [NeZero 1]
{n : ℕ} [inst_5 : n.AtLeastTwo], (0 < OfNat.ofNat n) = True | false |
LeftInvariantDerivation.instAddCommGroup._proof_1 | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | ∀ {𝕜 : 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} {G : Type u_4}
[inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Monoid G] [inst_7 : ContMDiff... | false |
NoZeroDivisors.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u_2} →
[inst : Mul M₀] →
[inst_1 : Zero M₀] →
{motive : NoZeroDivisors M₀ → Sort u} →
((eq_zero_or_eq_zero_of_mul_eq_zero : ∀ {a b : M₀}, a * b = 0 → a = 0 ∨ b = 0) → motive ⋯) →
(t : NoZeroDivisors M₀) → motive t | false |
WithTop.exists | Mathlib.Order.WithBot | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∃ x, p x) ↔ p ⊤ ∨ ∃ x, p ↑x | true |
Std.DTreeMap.Const.get!_ofList_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β} [inst : Inhabited β],
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → Std.DTreeMap.Const.get! (Std.DTreeMap.Const.ofList l cmp) k' = v | true |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.visit._sparseCasesOn_1 | Lean.Meta.Sym.AlphaShareCommon | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.Order.prod_csup_eq | Init.Internal.Order.Basic | ∀ {α : Sort u} {β : Sort v} [inst : Lean.Order.CCPO α] [inst_1 : Lean.Order.CCPO β] (c : α ×' β → Prop)
(hchain : Lean.Order.chain c), Lean.Order.prod_csup c hchain = Lean.Order.CCPO.csup hchain | true |
MeasurableSpace.measurableSet_invariants | Mathlib.MeasureTheory.MeasurableSpace.Invariants | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → α} {s : Set α}, MeasurableSet s ↔ MeasurableSet s ∧ f ⁻¹' s = s | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Mathlib.Linter.DirectoryDependency.NamePrefixRel.getAllLeft | Mathlib.Tactic.Linter.DirectoryDependency | Mathlib.Linter.DirectoryDependency.NamePrefixRel✝ → Lean.Name → Lean.NameSet | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.