name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Lsp.LeanModule.rec | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanModule → Sort u} →
((name : String) →
(uri : Lean.Lsp.DocumentUri) → (data? : Option Lean.Json) → motive { name := name, uri := uri, data? := data? }) →
(t : Lean.Lsp.LeanModule) → motive t | false |
Std.ExtDTreeMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
[inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List α} {k : α},
k ∉ t → l.contains k = false → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey? k = none | true |
Graph.noConfusionType | Mathlib.Combinatorics.Graph.Basic | Sort u → {α : Type u_3} → {β : Type u_4} → Graph α β → {α' : Type u_3} → {β' : Type u_4} → Graph α' β' → Sort u | false |
CategoryTheory.Equivalence.counit_naturality_assoc._to_dual_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {X Y : D} (f : Y ⟶ X) {Z : D} (h : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (e.counitInv.app Y))
(e.functor.map (e.inverse.map f)) =
C... | false |
Lean.MonadError.toAddErrorMessageContext | Lean.Exception | {m : Type → Type} → [self : Lean.MonadError m] → Lean.AddErrorMessageContext m | true |
CategoryTheory.DifferentialObject.shiftFunctor | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddCommGroupWithOne S] →
(C : Type u) →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
S → CategoryTheory.Functor (CategoryTheory.DifferentialObject S C) (Cate... | true |
_private.Lean.Level.0.Lean.Level.data.match_1 | Lean.Level | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((mvarId : Lean.LMVarId) → motive (Lean.Level.mvar mvarId)) →
((name : Lean.Name) → motive (Lean.Level.param name)) →
((u : Lean.Level) → motive u.succ) →
((u v : Lean.Level) → motive (u.max... | false |
CategoryTheory.AddMon.monMonoidal | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.MonoidalCategory (CategoryTheory.AddMon C) | true |
Lean.Grind.CommRing.Poly.pow._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_finitary._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : Set β → Prop}, (∀ t ⊆ f '' s, p t) = ∀ t ⊆ s, p (f '' t) | false |
Float32.isInf | Init.Data.Float32 | Float32 → Bool | true |
ByteArray.Iterator.remainingBytes | Init.Data.ByteArray.Basic | ByteArray.Iterator → ℕ | true |
Lean.Parser.withOpen.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | true |
_private.Init.Data.String.Substring.0.Substring.Raw.nextn.match_1.eq_1 | Init.Data.String.Substring | ∀ (motive : Substring.Raw → ℕ → String.Pos.Raw → Sort u_1) (x : Substring.Raw) (p : String.Pos.Raw)
(h_1 : (x : Substring.Raw) → (p : String.Pos.Raw) → motive x 0 p)
(h_2 : (ss : Substring.Raw) → (i : ℕ) → (p : String.Pos.Raw) → motive ss i.succ p),
(match x, 0, p with
| x, 0, p => h_1 x p
| ss, i.succ, p... | true |
Unitary.path._proof_2 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)),
selfAdjoint.expUnitary (↑0 • Unitary.argSelfAdjoint (v * star u)) * u = u | false |
Set.image2_image2_image2_comm | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9} {ε' : Type u_10} {ζ : Type u_11}
{ζ' : Type u_12} {ν : Type u_13} {s : Set α} {t : Set β} {u : Set γ} {v : Set δ} {f : ε → ζ → ν} {g : α → β → ε}
{h : γ → δ → ζ} {f' : ε' → ζ' → ν} {g' : α → γ → ε'} {h' : β → δ → ζ'},
(∀ (a : α) (b : β) ... | true |
WeierstrassCurve.Projective.neg_equiv | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P Q : Fin 3 → R}, P ≈ Q → W'.neg P ≈ W'.neg Q | true |
Mathlib.Meta.FunProp.Context._sizeOf_1 | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Context → ℕ | false |
_private.Mathlib.Algebra.BigOperators.Group.Multiset.Basic.0.Multiset.prod_dvd_prod_of_le._simp_1_1 | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {α : Type u_1} [inst : Semigroup α] (a b : α), (a ∣ a * b) = True | false |
_private.Mathlib.NumberTheory.NumberField.Discriminant.Basic.0.NumberField.exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr._simp_1_5 | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | false |
Int.lcm_mul_left_left_eq_mul_of_lcm_eq_mul | Init.Data.Int.Gcd | ∀ {n m k : ℤ}, n.lcm m = n.natAbs * m.natAbs → (k * n).lcm m = n.natAbs * k.lcm m | true |
IsIdempotentElem.add_sub_mul_of_commute | Mathlib.Algebra.Ring.Idempotent | ∀ {R : Type u_1} [inst : NonUnitalRing R] {a b : R},
Commute a b → IsIdempotentElem a → IsIdempotentElem b → IsIdempotentElem (a + b - a * b) | true |
CategoryTheory.Adjunction.LeftAdjointCommShift.iso_hom_app_assoc | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {A : Type u_3} [inst_2 : AddGroup A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShif... | true |
PUnit.instSMulZeroClass._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : Zero R] (x : PUnit.{u_1 + 1}), x • 0 = x • 0 | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_3.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (x y : (CategoryTheory.WithInitial C)ᵒᵖ) → (Opposite.unop y ⟶ Opposite.unop x) → (x ⟶ y) → Sort u_3) (a : C)
(x :
Opposite.unop (Opposite.op CategoryTheory.WithInitial.star) ⟶
Opposite.unop (Opposite.op (CategoryTheory.WithInitial.of... | true |
LieSubmodule.mem_baseChange_iff | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : CommRing A] [inst_8 : Algebra R A] {N : LieSubmodule R L M}
{m : Tensor... | true |
_private.Mathlib.Data.EReal.Inv.0.EReal.sign_mul_inv_abs._simp_1_1 | Mathlib.Data.EReal.Inv | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] [AddLeftMono α] [AddRightMono α] (a : α), (0 ≤ |a|) = True | false |
fixedPoints.completeLattice._proof_1 | Mathlib.Order.FixedPoints | ∀ {α : Type u_1} [inst : CompleteLattice α] (f : α →o α) (a b : ↑(Function.fixedPoints ⇑f)), SemilatticeInf.inf a b ≤ a | false |
SimpleGraph.Walk.ofDarts | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} →
{G : SimpleGraph V} →
(l : List G.Dart) →
(hne : l ≠ []) → List.IsChain G.DartAdj l → G.Walk (l.head hne).toProd.1 (l.getLast hne).toProd.2 | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne.0.SimplexCategory.toMk₁._proof_3 | Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j₁ j₂ : Fin ((SimplexCategory.mk n).len + 1)),
j₁ ≤ j₂ → ¬j₁.castSucc < i → j₂.castSucc < i → 1 ≤ 0 | false |
RingQuot.wrapped._@.Mathlib.Algebra.RingQuot.3673095128._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | Subtype (Eq RingQuot.definition✝) | false |
tprod_congr_subtype | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] (f : β → α) {P Q : β → Prop},
(∀ (x : β), P x ↔ Q x) → ∏' (x : { x // P x }), f ↑x = ∏' (x : { x // Q x }), f ↑x | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_one._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
_private.Mathlib.Analysis.InnerProductSpace.Spectrum.0.LinearMap.IsSymmetric.roots_charpoly_eq_eigenvalues._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∏ x ∈ s, f x ≠ 0) = ∀ a ∈ s, f a ≠ 0 | false |
Std.DTreeMap.Internal.Impl.minKey?_insertIfNew!_le_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {v : β k} {km kmi : α},
t.minKey? = some km →
(Std.DTreeMap.Internal.Impl.insertIfNew! k v t).minKey?.get ⋯ = kmi → (compare kmi km).isLE = true | true |
SSet.QCat.bicategory | Mathlib.AlgebraicTopology.Quasicategory.StrictBicategory | CategoryTheory.Bicategory SSet.QCat | true |
unitary.norm_expUnitary_smul_argSelfAdjoint_sub_one_le | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u : ↥(unitary A)) {t : ℝ},
t ∈ Set.Icc 0 1 → ‖↑u - 1‖ < 2 → ‖↑(selfAdjoint.expUnitary (t • Unitary.argSelfAdjoint u)) - 1‖ ≤ ‖↑u - 1‖ | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Decl.inlineAttr.match_1 | Lean.Compiler.LCNF.Basic | (motive : Option Lean.Compiler.InlineAttributeKind → Sort u_1) →
(x : Option Lean.Compiler.InlineAttributeKind) →
(Unit → motive (some Lean.Compiler.InlineAttributeKind.inline)) →
((x : Option Lean.Compiler.InlineAttributeKind) → motive x) → motive x | false |
Polynomial.coeff_natDegree | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.coeff p.natDegree = p.leadingCoeff | true |
UniqueFactorizationMonoid.exists_reduced_factors' | Mathlib.RingTheory.UniqueFactorizationDomain.Basic | ∀ {R : Type u_2} [inst : CommMonoidWithZero R] [UniqueFactorizationMonoid R] (a b : R),
b ≠ 0 → ∃ a' b' c', IsRelPrime a' b' ∧ c' * a' = a ∧ c' * b' = b | true |
Semifield.recOn | Mathlib.Algebra.Field.Defs | {K : Type u_2} →
{motive : Semifield K → Sort u} →
(t : Semifield K) →
([toCommSemiring : CommSemiring K] →
[toInv : Inv K] →
[toDiv : Div K] →
(div_eq_mul_inv : ∀ (a b : K), a / b = a * b⁻¹) →
(zpow : ℤ → K → K) →
(zpow_zero' : ∀ (a : K)... | false |
Multipliable.tprod_eq_one_iff | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommMonoid α] [inst_1 : PartialOrder α] [IsOrderedMonoid α]
[CanonicallyOrderedMul α] [inst_4 : TopologicalSpace α] [OrderClosedTopology α] {f : ι → α},
Multipliable f → (∏' (i : ι), f i = 1 ↔ ∀ (x : ι), f x = 1) | true |
_private.Lean.Environment.0.Lean.EnvExtension.envExtensionsRef._proof_1 | Lean.Environment | Nonempty (ST.Ref IO.RealWorld (Array (Lean.EnvExtension Lean.EnvExtensionState))) | false |
MeasureTheory.Lp.coeFn_compMeasurePreserving | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {β : Type u_7} [inst_1 : MeasurableSpace β] {μb : MeasureTheory.Measure β} {f : α → β}
(g : ↥(MeasureTheory.Lp E p μb)) (hf : MeasureTheory.MeasurePreserving f μ μb),
↑↑((MeasureTheory... | true |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.true.sizeOf_spec | Lean.Meta.InferType | sizeOf Lean.Meta.ArrowPropResult.true✝ = 1 | true |
SetLike.GradeZero.instCommRing | Mathlib.Algebra.DirectSum.Internal | {ι : Type u_1} →
{σ : Type u_2} →
{R : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommMonoid ι] →
[inst_2 : SetLike σ R] → [AddSubgroupClass σ R] → (A : ι → σ) → [SetLike.GradedMonoid A] → CommRing ↥(A 0) | true |
Descriptive.Tree.instTransListSubtypeSetMemCompleteSublatticeTreeIsPrefix | Mathlib.SetTheory.Descriptive.Tree | {A : Type u_1} → Trans List.IsPrefix (fun x T => x ∈ T) fun x T => x ∈ T | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_le_minKey!_erase._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Mathlib.Tactic.Simp.evalFinsetIccNat._unary | Mathlib.Tactic.Simproc.FinsetInterval | ℕ → (en : Q(ℕ)) → (_x : (_ : ℕ) ×' Q(ℕ)) → Lean.MetaM ((s : Q(Finset ℕ)) × Q(Finset.Icc unknown_1 «$en» = «$s»)) | false |
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augmentTruncate.match_1 | Mathlib.Algebra.Homology.Augment | ∀ (motive : ℕ → Prop) (i : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive i | false |
_private.Mathlib.Combinatorics.SetFamily.KruskalKatona.0.Finset.Colex.shadow_initSeg._simp_1_10 | Mathlib.Combinatorics.SetFamily.KruskalKatona | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
Polynomial.rootMultiplicity_eq_nat_find_of_nonzero | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] {p : Polynomial R} (p0 : p ≠ 0) {a : R}
[inst_1 : DecidablePred fun n => ¬(Polynomial.X - Polynomial.C a) ^ (n + 1) ∣ p],
Polynomial.rootMultiplicity a p = Nat.find ⋯ | true |
CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_right_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (s : CategoryTheory.Limits.Cofork f g)
{Z : C}
(h :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
Z),
CategoryTheory.Categor... | true |
Set.instCompleteAtomicBooleanAlgebra._proof_3 | Mathlib.Data.Set.BooleanAlgebra | ∀ {α : Type u_1} (a : Set α), a ≤ ⊤ | false |
NumberField.InfiniteAdeleRing.instAlgebra | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) → [inst : Field K] → Algebra K (NumberField.InfiniteAdeleRing K) | true |
EReal.expOrderIso_apply | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLogExp | ∀ (x : EReal), EReal.expOrderIso x = x.exp | true |
Array.size_extract | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {start stop : ℕ}, (xs.extract start stop).size = min stop xs.size - start | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map₂ | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) →
{a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (self.map f ⟶ self.map g) | true |
Set.addAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | {α : Type u_1} → [Add α] → Set α → Set α → α → Set (α × α) | true |
_private.Lean.Elab.Command.0.Lean.Elab.Command.liftTermElabM.match_1 | Lean.Elab.Command | {α : Type} →
(motive : (Except Lean.Exception α × Lean.Elab.Term.State) × Lean.Meta.State → Sort u_1) →
(__discr : (Except Lean.Exception α × Lean.Elab.Term.State) × Lean.Meta.State) →
((ea : Except Lean.Exception α) →
(snd : Lean.Elab.Term.State) → (snd_1 : Lean.Meta.State) → motive ((ea, snd), s... | false |
String.Slice.Pos.inner_down | Init.Data.String.Termination | ∀ {s : String.Slice} {p : s.Pos}, p.down.inner = p | true |
Std.ExtTreeMap.maxKey!_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β},
(t.insertIfNew k v).maxKey! = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | true |
Con.instCompleteLattice._proof_8 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] (s : Set (Con M)), IsGLB s (sInf s) | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastUdivOutput.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | ∀ {α : Type} {inst : Hashable α} {inst_1 : DecidableEq α} {old : Std.Sat.AIG α} {w : ℕ} {aig : Std.Sat.AIG α}
{q r : aig.RefVec w} {hle : old.decls.size ≤ aig.decls.size} {aig_1 : Std.Sat.AIG α} {q_1 r_1 : aig_1.RefVec w}
{hle_1 : old.decls.size ≤ aig_1.decls.size},
{ aig := aig, q := q, r := r, hle := hle } = { ... | true |
emultiplicity_pow_self_of_prime | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] {p : α},
Prime p → ∀ (n : ℕ), emultiplicity p (p ^ n) = ↑n | true |
Cardinal.not_isSuccLimit_natCast | Mathlib.SetTheory.Cardinal.Basic | ∀ (n : ℕ), ¬Order.IsSuccLimit ↑n | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isProp.match_4 | Lean.Meta.InferType | (motive : Lean.LBool → Sort u_1) →
(__do_lift : Lean.LBool) →
(Unit → motive Lean.LBool.true) →
(Unit → motive Lean.LBool.false) → (Unit → motive Lean.LBool.undef) → motive __do_lift | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.weaken_doubling | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G},
↑(A * A).card < 3 / 2 * ↑A.card → (A * A).card < 2 * A.card | true |
Polynomial.Chebyshev.T_complex_cosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Basic | ∀ (θ : ℂ) (n : ℤ), Polynomial.eval (Complex.cosh θ) (Polynomial.Chebyshev.T ℂ n) = Complex.cosh (↑n * θ) | true |
SimpleGraph.edgeSet_top | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u}, ⊤.edgeSet = Sym2.diagSetᶜ | true |
IsClosed.lowerSemicontinuousWithinAt_indicator | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {s t : Set α} {x : α} {y : β} [inst_1 : Zero β]
[inst_2 : Preorder β], IsClosed s → y ≤ 0 → LowerSemicontinuousWithinAt (s.indicator fun _x => y) t x | true |
CoxeterSystem.recOn | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{M : CoxeterMatrix B} →
{W : Type u_2} →
[inst : Group W] →
{motive : CoxeterSystem M W → Sort u} →
(t : CoxeterSystem M W) → ((mulEquiv : W ≃* M.Group) → motive { mulEquiv := mulEquiv }) → motive t | false |
tendsto_rpow_atBot_of_base_gt_one | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ (b : ℝ), 1 < b → Filter.Tendsto (fun x => b ^ x) Filter.atBot (nhds 0) | true |
_private.Mathlib.RingTheory.MvPolynomial.Homogeneous.0.MvPolynomial.IsHomogeneous.prod._proof_1_4 | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_2} {R : Type u_3} [inst : CommSemiring R] {ι : Type u_1} (φ : ι → MvPolynomial σ R) (n : ι → ℕ) (i : ι)
(s : Finset ι), (∀ i_1 ∈ insert i s, (φ i_1).IsHomogeneous (n i_1)) → ∀ i_1 ∈ s, (φ i_1).IsHomogeneous (n i_1) | false |
tendsto_integral_comp_smul_smul_of_integrable | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {F : Type u_4}
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [FiniteDimensional ℝ F] [inst_6 : MeasurableSpace F]
[BorelSpace F] {μ : MeasureTheory.Measure F} [μ.IsAddHaarMeasure] {φ : F → ℝ},
(∀ (x : F), 0 ≤ ... | true |
Function.MulExact.comp_injective | Mathlib.Algebra.Exact | ∀ {M : Type u_2} {N : Type u_4} {P : Type u_6} {P' : Type u_7} {f : M → N} {g : N → P} (g' : P → P') [inst : One P]
[inst_1 : One P'], Function.MulExact f g → Function.Injective g' → g' 1 = 1 → Function.MulExact f (g' ∘ g) | true |
CategoryTheory.hasCodetector_op_iff | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.HasCodetector Cᵒᵖ ↔ CategoryTheory.HasDetector C | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_diff_eq_false_of_contains_right._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 |
Computable.vector_ofFn | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] {n : ℕ} {f : Fin n → α → σ},
(∀ (i : Fin n), Computable (f i)) → Computable fun a => List.Vector.ofFn fun i => f i a | true |
IsOpenMap.adjunctionNhds._proof_5 | Mathlib.Topology.Category.TopCat.OpenNhds | ∀ {X Y : TopCat} {f : X ⟶ Y} (h : IsOpenMap ⇑(CategoryTheory.ConcreteCategory.hom f)) (x : ↑X)
(X_1 : TopologicalSpace.OpenNhds x),
CategoryTheory.CategoryStruct.comp
((h.functorNhds x).map ({ app := fun x_1 => CategoryTheory.homOfLE ⋯, naturality := ⋯ }.app X_1))
({ app := fun x_1 => CategoryTheory.hom... | false |
NonUnitalSubring.copy | Mathlib.RingTheory.NonUnitalSubring.Defs | {R : Type u} → [inst : NonUnitalNonAssocRing R] → (S : NonUnitalSubring R) → (s : Set R) → s = ↑S → NonUnitalSubring R | true |
Lean.Doc.instAppendDocCode | Lean.Elab.DocString.Builtin | Append Lean.Doc.DocCode | true |
ByteArray.validateUTF8._proof_1 | Init.Data.String.Basic | ∀ (b : ByteArray) (i : ℕ) (hi : i < b.size) (h : b.validateUTF8At i = true), i + b[i].utf8ByteSize ⋯ ≤ b.size | false |
exists_covBy_of_wellFoundedGT | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] [wf : WellFoundedGT α] ⦃a : α⦄, ¬IsMin a → ∃ a', a' ⋖ a | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.DefEqM.Context.zetaDelta | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.DefEqM.Context✝ → Bool | true |
isLowerSet_empty | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α], IsLowerSet ∅ | true |
Std.TreeMap.Raw.Equiv.getKeyLT?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getKeyLT? k = t₂.getKeyLT? k | true |
MeasureTheory.Measure.everywherePosSubset_ae_eq | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α}
[OpensMeasurableSpace α] [μ.InnerRegular], MeasurableSet s → μ.everywherePosSubset s =ᵐ[μ] s | true |
Turing.ToPartrec.instInhabitedCode.default | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code | true |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.CollectState.thms | Lean.Meta.Tactic.Grind.EMatchAction | Lean.Meta.Grind.Action.CollectState✝ → Array Lean.Meta.Grind.EMatchTheorem | true |
AlgebraicGeometry.ValuativeCriterion.Uniqueness | Mathlib.AlgebraicGeometry.ValuativeCriterion | CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme | true |
MeasureTheory.ae_eq_dirac | Mathlib.MeasureTheory.Measure.Dirac | ∀ {α : Type u_1} {δ : Type u_3} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {a : α} (f : α → δ),
f =ᵐ[MeasureTheory.Measure.dirac a] Function.const α (f a) | true |
dirichletSummandHom | Mathlib.NumberTheory.EulerProduct.DirichletLSeries | {s : ℂ} → {n : ℕ} → DirichletCharacter ℂ n → s ≠ 0 → ℕ →*₀ ℂ | true |
UpperHalfPlane.σ | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | GL (Fin 2) ℝ → ℂ ≃A[ℝ] ℂ | true |
_private.Mathlib.Data.Fin.Tuple.Finset.0.Finset.map_consEquiv_filter_piFinset._simp_1_1 | Mathlib.Data.Fin.Tuple.Finset | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = (P 0 ∧ ∀ (i : Fin n), P i.succ) | false |
lt_inv_comm₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] [MulPosReflectLT G₀]
{a b : G₀}, 0 < a → 0 < b → (a < b⁻¹ ↔ b < a⁻¹) | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.CNF.0.Std.Tactic.BVDecide.LRAT.Internal.Clause.limplies_iff_mem._proof_1_5 | Std.Tactic.BVDecide.LRAT.Internal.CNF | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Clause α β]
(l : Std.Sat.Literal α) (c : β),
((fun x => if x = l.1 then l.2 else decide ((x, false) ∈ Std.Tactic.BVDecide.LRAT.Internal.Clause.toList c)) l.1 =
l.2 →
∃ a,
(a, false) ∈ Std.Tactic.... | false |
_private.Init.Data.Array.Zip.0.Array.getElem?_zipWithAll.match_1.eq_2 | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : Option α → Option β → Sort u_3) (a? : Option α) (b? : Option β)
(h_1 : Unit → motive none none) (h_2 : (a? : Option α) → (b? : Option β) → motive a? b?),
(a? = none → b? = none → False) →
(match a?, b? with
| none, none => h_1 ()
| a?, b? => h_2 a? b?) =
... | true |
ProofWidgets.ExprWithCtx.rec | ProofWidgets.Compat | {motive : ProofWidgets.ExprWithCtx → Sort u} →
((ci : Lean.Elab.ContextInfo) →
(lctx : Lean.LocalContext) →
(linsts : Lean.LocalInstances) →
(expr : Lean.Expr) → motive { ci := ci, lctx := lctx, linsts := linsts, expr := expr }) →
(t : ProofWidgets.ExprWithCtx) → motive t | false |
ZFSet.IsOrdinal.isTrichotomous | Mathlib.SetTheory.ZFC.Ordinal | ∀ {x : ZFSet.{u}}, x.IsOrdinal → Std.Trichotomous (Subrel (fun x1 x2 => x1 ∈ x2) fun x_1 => x_1 ∈ x) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.