name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
bddAbove_smul_iff_of_pos._simp_1 | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : GroupWithZero α] [inst_3 : Zero β]
[inst_4 : MulActionWithZero α β] [PosSMulMono α β] [PosSMulReflectLE α β] {s : Set β} {a : α},
0 < a → BddAbove (a • s) = BddAbove s | false |
Filter.Realizer.ofEquiv._proof_5 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {τ : Type u_2} {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ), (CFilter.ofEquiv E F.F).toFilter = f | false |
_private.Init.WF.0.PSigma.revLex.match_1_1 | Init.WF | ∀ {α : Sort u_1} {β : Sort u_2} (motive : (_ : α) ×' β → Prop) (x : (_ : α) ×' β),
(∀ (a : α) (b : β), motive ⟨a, b⟩) → motive x | false |
ImplicitFunctionData.noConfusion | Mathlib.Analysis.Calculus.Implicit | {P : Sort u} →
{𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{E : Type u_2} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : NormedSpace 𝕜 E} →
{inst_3 : CompleteSpace E} →
{F : Type u_3} →
{inst_4 : NormedAddCommGroup F} →
... | false |
CompleteLatticeHom.casesOn | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
[inst : CompleteLattice α] →
[inst_1 : CompleteLattice β] →
{motive : CompleteLatticeHom α β → Sort u} →
(t : CompleteLatticeHom α β) →
((tosInfHom : sInfHom α β) →
(map_sSup' : ∀ (s : Set α), tosInfHom.toFun (sSup s) = sSup (to... | false |
_private.Mathlib.RingTheory.Nilpotent.Defs.0.IsNilpotent.map_iff.match_1_1 | Mathlib.RingTheory.Nilpotent.Defs | ∀ {R : Type u_3} {S : Type u_1} [inst : MonoidWithZero S] {r : R} {F : Type u_2} [inst_1 : FunLike F R S] {f : F}
(motive : IsNilpotent (f r) → Prop) (x : IsNilpotent (f r)), (∀ (k : ℕ) (hk : f r ^ k = 0), motive ⋯) → motive x | false |
Lean.PrettyPrinter.Formatter.error.formatter | Lean.PrettyPrinter.Formatter | String → Lean.PrettyPrinter.Formatter | true |
AbstractCompletion.compare_coe | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α) (pkg' : AbstractCompletion.{vα', uα} α)
(a : α), pkg.compare pkg' (pkg.coe a) = pkg'.coe a | true |
ULift.monoid | Mathlib.Algebra.Group.ULift | {α : Type u} → [Monoid α] → Monoid (ULift.{u_1, u} α) | true |
derivationQuotKerSq._proof_1 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (P : Type u_1) (S : Type u_2) [inst : CommRing P] [inst_1 : CommRing S] [inst_2 : Algebra P S],
SMulCommClass P (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S | false |
WeakFEPair.hf_top | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (self : WeakFEPair E) (r : ℝ),
(fun x => self.f x - self.f₀) =O[Filter.atTop] fun x => x ^ r | true |
Mathlib.Tactic.ITauto.AndKind.and.sizeOf_spec | Mathlib.Tactic.ITauto | sizeOf Mathlib.Tactic.ITauto.AndKind.and = 1 | true |
Vector.find?_eq_map_findFinIdx?_getElem | Init.Data.Vector.Find | ∀ {α : Type} {n : ℕ} {xs : Vector α n} {p : α → Bool},
Vector.find? p xs = Option.map (fun x => xs[x]) (Vector.findFinIdx? p xs) | true |
MeasureTheory.StronglyMeasurable.finStronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : TopologicalSpace β] [inst_1 : Zero β] {m0 : MeasurableSpace α},
MeasureTheory.StronglyMeasurable f →
∀ (μ : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ], MeasureTheory.FinStronglyMeasurable f μ | true |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.wrapped._proof_1._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | @definition✝ = @definition✝ | false |
LinearMap.singularValues_of_finrank_le | Mathlib.Analysis.InnerProductSpace.SingularValues | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : InnerProductSpace 𝕜 F]
[inst_6 : FiniteDimensional 𝕜 F] (T : E →ₗ[𝕜] F) {i : ℕ}, Module.finrank 𝕜 E ≤ i... | true |
ProbabilityTheory.geometricMeasure | Mathlib.Probability.Distributions.Geometric | {p : ℝ} → 0 < p → p ≤ 1 → MeasureTheory.Measure ℕ | true |
QuotientGroup.quotientRightRelEquivQuotientLeftRel._proof_1 | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) (a b : α),
(QuotientGroup.rightRel s) a b → (QuotientGroup.leftRel s) ((fun g => g⁻¹) a) ((fun g => g⁻¹) b) | false |
Lean.Json.ctorIdx | Lean.Data.Json.Basic | Lean.Json → ℕ | false |
GrpCat.limitGroup._aux_14 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J GrpCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget GrpCat)).sections] →
(CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget GrpCat))).pt →
(Categ... | false |
Submodule.isOrtho_top_right | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U : Submodule 𝕜 E}, U ⟂ ⊤ ↔ U = ⊥ | true |
_private.Mathlib.Data.Set.Lattice.0.Set.nonempty_iUnion._simp_1_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | false |
ContinuousLinearMap.NonlinearRightInverse.casesOn | Mathlib.Analysis.Normed.Operator.Banach | {𝕜 : Type u_1} →
{𝕜' : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NontriviallyNormedField 𝕜'] →
{σ : 𝕜 →+* 𝕜'} →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{F : Type u_4} →
... | false |
Rep.instEnoughProjectives | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Monoid G], CategoryTheory.EnoughProjectives (Rep.{max w u, u, u} k G) | true |
Std.DTreeMap.Internal.Impl.balanceL.match_5 | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(rs : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond l_1... | false |
RootedTree.mem_subtrees_disjoint_iff | Mathlib.Order.SuccPred.Tree | ∀ {t : RootedTree} {t₁ t₂ : SubRootedTree t},
t₁ ∈ t.subtrees → t₂ ∈ t.subtrees → ∀ (v₁ v₂ : ↑t), v₁ ∈ t₁ → v₂ ∈ t₂ → (Disjoint v₁ v₂ ↔ t₁ ≠ t₂) | true |
Ideal.IsMaximal.mk | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, IsCoatom I → I.IsMaximal | true |
Lean.KVMap.find | Lean.Data.KVMap | Lean.KVMap → Lean.Name → Option Lean.DataValue | true |
CategoryTheory.MorphismProperty.llp_rlp_of_hasSmallObjectArgument | Mathlib.CategoryTheory.SmallObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C)
[I.HasSmallObjectArgument],
I.rlp.llp =
(CategoryTheory.MorphismProperty.transfiniteCompositions.{w, v, u}
(CategoryTheory.MorphismProperty.coproducts.{w, v, u} I).pushouts).retracts | true |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.mk._flat_ctor | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →... | false |
Unitary.conjStarAlgEquiv_unitaryLinearIsometryEquiv | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] (u : ↥(unitary (H →L[𝕜] H))),
(Unitary.linearIsometryEquiv u).conjStarAlgEquiv = (Unitary.conjStarAlgAut 𝕜 (H →L[𝕜] H)) u | true |
OrderTopology.mk._flat_ctor | Mathlib.Topology.Order.Basic | ∀ {α : Type u_1} [t : TopologicalSpace α] [inst : Preorder α],
t = TopologicalSpace.generateFrom {s | ∃ a, s = Set.Ioi a ∨ s = Set.Iio a} → OrderTopology α | false |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.isLittleO_exp_comp_exp_comp._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {l : Filter α} {f g : α → 𝕜},
(∀ (x : α), g x = 0 → f x = 0) → f =o[l] g = Filter.Tendsto (fun x => f x / g x) l (nhds 0) | false |
NonUnitalNonAssocRing.toAddCommGroup | Mathlib.Algebra.Ring.Defs | {α : Type u} → [self : NonUnitalNonAssocRing α] → AddCommGroup α | true |
TensorProduct.prodRight_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Prod | ∀ (R : Type u_1) (S : Type u_2) (M₁ : Type u_3) (M₂ : Type u_4) (M₃ : Type u_5) [inst : CommSemiring R]
[inst_1 : Semiring S] [inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : AddCommMonoid M₃]
[inst_5 : Algebra R S] [inst_6 : Module R M₁] [inst_7 : Module S M₁] [inst_8 : IsScalarTower R S M₁]
[in... | true |
Filter.zero_pow_eventuallyEq | Mathlib.Order.Filter.AtTopBot.Ring | ∀ {α : Type u_1} [inst : MonoidWithZero α], (fun n => 0 ^ n) =ᶠ[Filter.atTop] fun x => 0 | true |
RingHom.injective_stableUnderComposition | Mathlib.RingTheory.RingHom.Injective | RingHom.StableUnderComposition fun {R S} [CommRing R] [CommRing S] f => Function.Injective ⇑f | true |
ENNReal.instMin | Mathlib.Data.ENNReal.Basic | Min ENNReal | true |
Function.piCongrLeft'_update | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} [inst : DecidableEq α] [inst_1 : DecidableEq β] (P : α → Sort u_10) (e : α ≃ β)
(f : (a : α) → P a) (b : β) (x : P (e.symm b)),
(Equiv.piCongrLeft' P e) (Function.update f (e.symm b) x) = Function.update ((Equiv.piCongrLeft' P e) f) b x | true |
CategoryTheory.HomOrthogonal.matrixDecompositionAddEquiv._proof_1 | Mathlib.CategoryTheory.Preadditive.HomOrthogonal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {ι : Type u_1} {s : ι → C}
[inst_1 : CategoryTheory.Preadditive C] [inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C]
(o : CategoryTheory.HomOrthogonal s) {α β : Type} [inst_3 : Finite α] [inst_4 : Finite β] {f : α → ι} {g : β → ι}
(w z : (⨁ fun a... | false |
_private.Mathlib.Algebra.Order.Ring.Abs.0.geomSum.match_1.splitter | Mathlib.Algebra.Order.Ring.Abs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | true |
CommMonCat.forget_createsLimit._proof_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {X Y : CommMonCat} (x : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.forget CommMonCat).map x)
(CategoryTheory.Iso.refl ((CategoryTheory.forget CommMonCat).obj Y)).hom =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.forget CommMonCat).map x)
(CategoryTheory.Iso.refl ((CategoryTh... | false |
String.Pos.Raw.zero_add_string_eq | Init.Data.String.PosRaw | ∀ (s : String), 0 + s = { byteIdx := s.utf8ByteSize } | true |
Lean.Compiler.LCNF.ToLCNF.Element.rec | Lean.Compiler.LCNF.ToLCNF | {motive : Lean.Compiler.LCNF.ToLCNF.Element → Sort u} →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.jp decl)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.fun decl... | false |
Topology.IsConstructible.image_of_isClosedEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set X},
Topology.IsClosedEmbedding f →
IsRetrocompact (Set.range f)ᶜ → Topology.IsConstructible s → Topology.IsConstructible (f '' s) | true |
Int.cast_prod | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_5} {R : Type u_6} [inst : CommRing R] (f : ι → ℤ) (s : Finset ι), ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i) | true |
DFinsupp.erase_single_ne | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] {i j : ι} (x : β i),
i ≠ j → (DFinsupp.erase j fun₀ | i => x) = fun₀ | i => x | true |
AddChar.PrimitiveAddChar.mk.noConfusion | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | {R : Type u} →
{inst : CommRing R} →
{R' : Type v} →
{inst_1 : Field R'} →
{P : Sort u_1} →
{n : ℕ+} →
{char : AddChar R (CyclotomicField (↑n) R')} →
{prim : char.IsPrimitive} →
{n' : ℕ+} →
{char' : AddChar R (CyclotomicField (↑n'... | false |
Nat.add_div_of_dvd_left | Mathlib.Data.Nat.ModEq | ∀ {a b c : ℕ}, c ∣ b → (a + b) / c = a / c + b / c | true |
CategoryTheory.Functor.map_comp._autoParam | Mathlib.CategoryTheory.Functor.Basic | Lean.Syntax | false |
Fin.reduceMod._regBuiltin.Fin.reduceMod.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2560743620._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | false |
Finset.normalize_gcd | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s : Finset β}
{f : β → α}, normalize (s.gcd f) = s.gcd f | true |
_private.Mathlib.Geometry.Euclidean.Sphere.Tangent.0.EuclideanGeometry.Sphere.isIntTangent_iff_dist_center._simp_1_8 | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
Nat.maxPowDiv.zero_base | Mathlib.Data.Nat.MaxPowDiv | ∀ (n : ℕ), padicValNat 0 n = 0 | true |
Filter.Germ.liftPred_coe._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {f : α → β},
Filter.Germ.LiftPred p ↑f = ∀ᶠ (x : α) in l, p (f x) | false |
Std.ExtTreeMap.instForInProdOfTransCmpOfLawfulMonad | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{m : Type w → Type w₂} →
[Std.TransCmp cmp] → [inst : Monad m] → [LawfulMonad m] → ForIn m (Std.ExtTreeMap α β cmp) (α × β) | true |
primitiveRoots_zero | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R], primitiveRoots 0 R = ∅ | true |
Mathlib.Tactic.FieldSimp.qNF.mkMulProof | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(l₁ l₂ : Mathlib.Tactic.FieldSimp.qNF M) →
have a := (l₁.mul l₂).toNF;
have a_1 := l₂.toNF;
have a_2 := l₁.toNF;
Q(«$a_2».eval * «$a_1».eval = «$a».eval) | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.length_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | true |
Lean.IR.FnBody.dec | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ → Bool → Bool → Lean.IR.FnBody → Lean.IR.FnBody | true |
SimpleGraph.CompleteEquipartiteSubgraph.toCopy._proof_6 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (K : G.CompleteEquipartiteSubgraph r t)
(this : Nonempty (Fin r ↪ ↥K.parts)) (this_1 : ∀ (p : ↥K.parts), Nonempty (Fin t ↪ ↥↑p)) {a b : Fin r × Fin t},
(SimpleGraph.completeEquipartiteGraph r t).Adj a b →
G.Adj (↑(((fun p => Classical.arbitrary (Fin t ↪ ↥↑p)) ((Cla... | false |
Aesop.Goal.parent | Aesop.Tree.Data | Aesop.Goal → Aesop.MVarClusterRef | true |
UniformSpace.Completion.ring._proof_2 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsUniformAddGroup α]
(_x_1 : ∀ (a b c : UniformSpace.Completion α), IsClosed {x | x.1 * x.2.1 * x.2.2 = x.1 * (x.2.1 * x.2.2)})
(_x_2 : ∀ (a b c : UniformSpace.Completion α) (a b c : α), ↑a * ↑b * ↑c = ↑a * (↑b * ↑c)),
(∀ (n : ℕ) (x : UniformSpa... | false |
Bool.toISize | Init.Data.SInt.Basic | Bool → ISize | true |
_private.Mathlib.Topology.NhdsWithin.0.mem_nhdsSet._simp_1_4 | Mathlib.Topology.NhdsWithin | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.biUnion._simp_3 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
CategoryTheory.Subgroupoid.sInf_isNormal | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (s : Set (CategoryTheory.Subgroupoid C)),
(∀ S ∈ s, S.IsNormal) → (sInf s).IsNormal | true |
Lean.Meta.Grind.IntrosResult.goal.noConfusion | Lean.Meta.Sym.Grind | {P : Sort u} →
{newDecls : Array Lean.FVarId} →
{goal : Lean.Meta.Grind.Goal} →
{newDecls' : Array Lean.FVarId} →
{goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntrosResult.goal newDecls goal = Lean.Meta.Grind.IntrosResult.goal newDecls' goal' →
(newDecls = newDecls' → goal ... | false |
Std.Sat.AIG.RefVec.push.eq_1 | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {len : ℕ} (ref : aig.Ref)
(refs : Vector Std.Sat.AIG.Fanin len) (hrefs : ∀ {i : ℕ} (h : i < len), refs[i].gate < aig.decls.size),
{ refs := refs, hrefs := hrefs }.push ref =
{ refs := refs.push (Std.Sat.AIG.Fanin.mk ref.gate ref.inv... | true |
IsTopologicalRing.of_norm | Mathlib.Topology.Algebra.Order.Field | ∀ {R : Type u_1} {𝕜 : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : Field 𝕜] [inst_2 : LinearOrder 𝕜]
[IsStrictOrderedRing 𝕜] [inst_4 : TopologicalSpace R] [IsTopologicalAddGroup R] (norm : R → 𝕜),
(∀ (x : R), 0 ≤ norm x) →
(∀ (x y : R), norm (x * y) ≤ norm x * norm y) →
((nhds 0).HasBasis (fu... | true |
Lean.MetavarContext.LevelMVarToParam.Context.noConfusionType | Lean.MetavarContext | Sort u → Lean.MetavarContext.LevelMVarToParam.Context → Lean.MetavarContext.LevelMVarToParam.Context → Sort u | false |
_private.Mathlib.Tactic.DeriveCountable.0.Mathlib.Deriving.Countable.mkInjThmMatch | Mathlib.Tactic.DeriveCountable | Lean.Elab.Deriving.Context → Lean.Elab.Deriving.Header → Lean.InductiveVal → Lean.Elab.TermElabM Lean.Term | true |
_private.Mathlib.Data.Set.Lattice.0.Set.nonempty_iInter._simp_1_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Extension.0.TopologicalGroup.IsSES.pushforward._simp_2 | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : TopologicalSpace β] {f : β → α},
Continuous f = ∀ (a : β), ∀ ε > 0, ∀ᶠ (x : β) in nhds a, dist (f x) (f a) < ε | false |
Bifunctor.ctorIdx | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} → Bifunctor F → ℕ | false |
SimplexCategory.II.map'_succAboveOrderEmb | Mathlib.AlgebraicTopology.SimplicialObject.II | ∀ {n : ℕ} (i : Fin (n + 2)) (x : Fin (n + 3)), SimplexCategory.II.map' i.succAboveOrderEmb.toOrderHom x = i.predAbove x | true |
_private.Mathlib.GroupTheory.CommutingProbability.0.DihedralGroup.commProb_reciprocal._proof_1_3 | Mathlib.GroupTheory.CommutingProbability | ∀ (n : ℕ), Odd (n % 4) → (n % 4 * n + 3) * 1 * n = 1 * (4 * (n % 4 * n) * (n / 4 + 1)) | false |
Rat.num_lt_succ_floor_mul_den | Mathlib.Data.Rat.Floor | ∀ (q : ℚ), q.num < (⌊q⌋ + 1) * ↑q.den | true |
IsPoly.sub | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} {f g : (α → ℕ) → ℤ}, IsPoly f → IsPoly g → IsPoly fun x => f x - g x | true |
Booleanisation.LT.comp | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] {a b : α},
a < b → (Booleanisation.comp b).LT (Booleanisation.comp a) | true |
Antitone.le_leftLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Antitone f → ∀ {x y : α}, x ≤ y → f y ≤ Function.leftLim f x | true |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_inv_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)) {Z : ↑(F.obj b)}
(h : (F.map f).toFunctor.obj ((F.map (CategoryTheory.CategoryStruct.id a)).toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.map f).toFu... | true |
Lean.Level.normalize._unsafe_rec | Lean.Level | Lean.Level → Lean.Level | false |
UpperSet.mem_mk | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : Set α} (hs : IsUpperSet s) {a : α}, a ∈ { carrier := s, upper' := hs } ↔ a ∈ s | true |
Set.le_mulIndicator_apply | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Type u_2} {M : Type u_3} [inst : LE M] [inst_1 : One M] {s : Set α} {g : α → M} {a : α} {y : M},
(a ∈ s → y ≤ g a) → (a ∉ s → y ≤ 1) → y ≤ s.mulIndicator g a | true |
CategoryTheory.ShortComplex.RightHomologyData.copy_ι | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {Q' H' : C} (eQ : Q' ≅ h.Q) (eH : H' ≅ h.H),
(h.copy eQ eH).ι = CategoryTheory.CategoryStruct.comp eH.hom (CategoryTheory.CategoryStruct.co... | true |
UpperHalfPlane.modular_S_smul | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (z : UpperHalfPlane), ModularGroup.S • z = { coe := (-↑z)⁻¹, coe_im_pos := ⋯ } | true |
ContDiff.comp_contDiffOn | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : 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] {n : WithTop ℕ∞} {s : Set E} {g : F →... | true |
LinearMap.inr_map_mul | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} [inst : Semiring R] {A : Type u_4} [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{B : Type u_5} [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] (b₁ b₂ : B),
(LinearMap.inr R A B) (b₁ * b₂) = (LinearMap.inr R A B) b₁ * (LinearMap.inr R A B) b₂ | true |
PFun.preimage_subset_dom | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) (s : Set β), f.preimage s ⊆ f.Dom | true |
NonUnitalSemiring | Mathlib.Algebra.Ring.Defs | Type u → Type u | true |
Std.Internal.List.getValueCast?.eq_def | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α) (x : List ((a : α) × β a)),
Std.Internal.List.getValueCast? a x =
match x with
| [] => none
| ⟨k, v⟩ :: l => if h : (k == a) = true then some (cast ⋯ v) else Std.Internal.List.getValueCast? a l | true |
Set.inter_nonempty | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty ↔ ∃ x ∈ s, x ∈ t | true |
IsValuativeTopology.hasBasis_nhds' | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R]
(x : R), (nhds x).HasBasis (fun x => x ≠ 0) fun x_1 => {y | (ValuativeRel.valuation R) (y - x) < x_1} | true |
ModularForm.eisensteinSeriesMF._proof_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ∀ {k : ℤ} {N : ℕ} [NeZero N],
3 ≤ k →
∀ (a : Fin 2 → ZMod N) {c : OnePoint ℝ},
IsCusp c (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N)) →
c.IsBoundedAt (⇑(EisensteinSeries.eisensteinSeriesSIF a k)) k | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.removeZeros.match_3 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(t : List ((ℤ × Q(«$M»)) × ℕ)) →
(motive :
((l' : Mathlib.Tactic.FieldSimp.qNF M) ×
let a := l'.toNF;
let a_1 := Mathlib.Tactic.FieldSimp.qNF.toNF t;
let foldr_1 :=
... | false |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalMod | Lean.Meta.Sym.Simp.EvalGround | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
_private.Lean.LocalContext.0.Lean.LocalContext.mkBinding.match_1 | Lean.LocalContext | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(n : Lean.Name) →
(ty : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) → motive (some (Lean.LocalDecl.cdecl index fvarI... | false |
Finset.traverse | Mathlib.Data.Finset.Functor | {α β : Type u} →
{F : Type u → Type u} →
[inst : Applicative F] → [CommApplicative F] → [DecidableEq β] → (α → F β) → Finset α → F (Finset β) | true |
Finset.forall | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {p : Finset α → Prop}, (∀ (s : Finset α), p s) ↔ ∀ (s : Set α) (hs : s.Finite), p hs.toFinset | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.