Theorem 4

Lax496464.Theorem4 · concepts/Lax496464/Theorem4.lean · lax-496464

proven

Loading review…

Sign in with ORCID

Community review

Flags

Each flag is tied to a public ORCID identity and explains why this concept may be incorrect.

No flags have been submitted.

    Community review

    Flag this concept

    State precisely what appears incorrect. This explanation will be public under your ORCID name.

    No source line selected.

    Natural Language Statement

    Theorem

    Two results for the case of equal preprocessing times.

    Without weights, the greedy of Section 6.1 solves the problem in O(nlog⁡n)O(n \log n) time, which is the cost of putting the jobs into earliest-start-time order; everything after that is one pass.

    With weights, on a proper instance, the integer program of Section 6.2 has a totally unimodular constraint matrix and can therefore be solved as a linear program, in polynomial time. That case is stated here only through its first half; see the notes.

    Concept map
    8 concepts
    100%
    Proven claimDefinitionThis conceptRelated conceptA → B: B builds on A
    Evidence

    Each proof establishes this claim relative to its assumptions.

    In the paper

    • page 6 of this submission's paper

    Lean source view on GitHub

    1import Lax496464.Problems
    2import Lax496464.ProperInstances
    3
    4/-!
    5---
    6title: Theorem 4
    7type: theorem
    8---
    9Two results for the case of equal preprocessing times.
    10
    11Without weights, the greedy of Section 6.1 solves the problem in O(nlog⁡n)O(n \log n) time,
    12which is the cost of putting the jobs into earliest-start-time order; everything after
    13that is one pass.
    14
    15With weights, on a proper instance, the integer program of Section 6.2 has a totally
    16unimodular constraint matrix and can therefore be solved as a linear program, in
    17polynomial time. That case is stated here only through its first half; see the notes.
    18
    19# Formalization Notes
    20
    21The first statement is the running time of the greedy, on the slice of instances with
    22equal preprocessing times and unit weights. Its bound is the sorting term alone, which is
    23what the paper's O(nlog⁡n)O(n \log n) says.
    24
    25The second bullet has **no running-time statement here**, and that is deliberate. The
    26O(n2.5L)O(n^{2.5} L) the paper quotes is the running time of a particular linear programming
    27algorithm, cited and not proved there, and the route from total unimodularity to an
    28integral optimum is the theorem of Hoffman and Kruskal, also cited. A running-time
    29statement for this case would therefore rest on two results from outside, neither of them
    30available in the background library, and asserting it would say nothing this submission
    31could support.
    32
    33What Section 6.2 does establish is stated in full elsewhere, and proved: the scheduling
    34problem *is* that integer program (`Lemma5.ilp_correct`, `Lemma5.ilp_optimum`), its
    35constraint matrix has the consecutive ones property on a proper instance
    36(`Lemma5.lemma5`), and such a matrix is totally unimodular
    37(`Lemma5.matrix_isTotallyUnimodular`, via `ConsecutiveOnes.isTotallyUnimodular`, which is
    38proved rather than assumed). That is the mathematical content of the bullet; the step from
    39it to a running time is the citation.
    40
    41The statement that remains is about the decision problem with a threshold, as the others
    42are, so that the whole submission speaks about one problem.
    43
    44The domain also asks that every processing time be positive, qj≥1q_j \ge 1. This is the paper's
    45standing assumption for the recursions behind the algorithms — a job with qj=0q_j = 0 has an
    46empty second operation, and the characterization of the feasible sets, on which everything
    47rests, is stated for jobs that have a genuine one — but the paper does not repeat it in each
    48claim, and a statement about a program that reads an arbitrary word has to.
    49-/
    50
    51namespace Lax496464.Theorem4
    52
    53open Lax496464.WordEncoding Lax496464.Problems Lax496464.ParameterizedComplexity
    54open Lax496464.ProperInstances
    55open Lax808846.Ram Lax808846.RamComputes
    56
    57open Classical in
    58/-- **Theorem 4, the unweighted case.** With equal preprocessing times and unit weights,
    59the problem is decided within `c · n log n` instructions. -/
    60axiom theorem4_greedy_time :
    61 ∃ (prog : Program) (c : ℕ), ∀ w : ℕ,
    62 ComputesInTime w prog
    63 {x | x ∈ DecisionInstances ∧ Fits c w x ∧
    64 (∃ I W, EncodesDecisionInstance x I W ∧ Uniform I) ∧
    65 (∀ j < jobCount x, wt x j = 1) ∧ (∀ j < jobCount x, 0 < procTime x j)}
    66 (fun x => if Yes x then [1] else [0])
    67 (fun x => c * sortCost x)
    68
    69end Lax496464.Theorem4
    70
    Show Proof
    Formalization Notes

    The first statement is the running time of the greedy, on the slice of instances with equal preprocessing times and unit weights. Its bound is the sorting term alone, which is what the paper's O(nlog⁡n)O(n \log n) says.

    The second bullet has no running-time statement here, and that is deliberate. The O(n2.5L)O(n^{2.5} L) the paper quotes is the running time of a particular linear programming algorithm, cited and not proved there, and the route from total unimodularity to an integral optimum is the theorem of Hoffman and Kruskal, also cited. A running-time statement for this case would therefore rest on two results from outside, neither of them available in the background library, and asserting it would say nothing this submission could support.

    What Section 6.2 does establish is stated in full elsewhere, and proved: the scheduling problem is that integer program (Lemma5.ilpcorrectLemma5.ilp_correct, Lemma5.ilpoptimumLemma5.ilp_optimum), its constraint matrix has the consecutive ones property on a proper instance (Lemma5.lemma5Lemma5.lemma5), and such a matrix is totally unimodular (Lemma5.matrixisTotallyUnimodularLemma5.matrix_isTotallyUnimodular, via ConsecutiveOnes.isTotallyUnimodularConsecutiveOnes.isTotallyUnimodular, which is proved rather than assumed). That is the mathematical content of the bullet; the step from it to a running time is the citation.

    The statement that remains is about the decision problem with a threshold, as the others are, so that the whole submission speaks about one problem.

    The domain also asks that every processing time be positive, qj≥1q_j \ge 1. This is the paper's standing assumption for the recursions behind the algorithms — a job with qj=0q_j = 0 has an empty second operation, and the characterization of the feasible sets, on which everything rests, is stated for jobs that have a genuine one — but the paper does not repeat it in each claim, and a statement about a program that reads an arbitrary word has to.

    Builds on
    Used by

    none

    From Mathlib

    none

    Discussion

    Ask a question or add context. Endorsements and structured flags are kept in the review panel above.

    Loading discussion…