According to me Option A and C are incorrect. I am able to get the schedule view serializable, T2 -> T1 as th…

Comments

• Vikram kumar18 Dec 2025

  @phanibhushanpanigrah yes you are absolutely correct option A and C are incorrect . reasoning: A. A write by an older transaction is not allowed if a younger transaction has already written that data item. C. cycle exits between T1 and T2 hope this helps, Keep learning!!

  • Phani BHUSHAN Panigrahi18 Dec 2025

    @lzor Then Option B and D are correct? for the given schedule.

• Sajal Gupta17 Dec 2025

  @phanibhushanpanigrah yes true, I also think option a and c are incorrect

• KG AI MentorKG AI Mentor9 Feb 2026

  You're on the right track with your analysis, but let's carefully go through the schedule and each option to determine which statements are incorrect. --- Given Schedule S:We have two transactions: T₁: BEGIN, R(A), W(A), COMMIT T₂: BEGIN, W(A), COMMIT And the timeline is: Time → T₁: BEGIN → R(A) → W(A) → COMMIT T₂: BEGIN → W(A) → COMMITSo the actual order of operations is: T₁: BEGIN T₁: R(A) T₂: BEGIN T₂: W(A) T₁: W(A) T₁: COMMIT T₂: COMMIT Wait — this is not possible as written. Let's re-express the timeline correctly. From the diagram: T₁ starts first: BEGIN, then R(A), then W(A), then COMMIT T₂ starts later: BEGIN, then W(A), then COMMIT But the timing shows that T₂'s W(A) happens before T₁'s W(A)? No — the diagram shows: T₁: BEGIN, R(A), W(A), COMMIT T₂: BEGIN, W(A), COMMIT And the vertical timeline shows T₁'s R(A) before T₂'s BEGIN, and T₂'s W(A) before T₁'s W(A). So the correct sequence is: T₁: BEGIN T₁: R(A) T₂: BEGIN T₂: W(A) T₁: W(A) T₁: COMMIT T₂: COMMIT So the actual order of operations is: T₁: R(A) T₂: W(A) T₁: W(A) This is a conflict because: T₁ reads A (R(A)) → T₂ writes A (W(A)) → T₁ writes A (W(A)) So T₁ reads A, then T₂ writes A, then T₁ writes A. But T₁ reads A before T₂ writes A — so T₁'s read is not affected by T₂'s write. But T₁ writes A after T₂ writes A — so T₁'s write overwrites T₂'s write. So the conflict is between T₂'s W(A) and T₁'s W(A) — they are conflicting write-write operations on A. --- Now, analyze each option:We are told: Timestamps: T₁ = 1, T₂ = 2 So T₁ is older than T₂ (smaller timestamp = older transaction) --- A. S is possible under basic Timestamp Ordering (TO) protocol.Basic Timestamp Ordering (TO) protocol rules: For each operation: - Read(A): If TS(T) < WTS(A) → abort (T reads a value written by a younger transaction) - Write(A): If TS(T) < RTS(A) → abort (T writes after a younger transaction read A) - Also, if TS(T) < WTS(A) → abort (T writes after a younger transaction wrote A) Let’s apply this to each operation. #### 1. T₁: R(A) TS(T₁) = 1 Initially, WTS(A) = 0, RTS(A) = 0 TS(T₁) = 1 > WTS(A) = 0 → OK So R(A) is allowed After R(A): RTS(A) = max(RTS(A), TS(T₁)) = max(0,1) = 1 #### 2. T₂: W(A) TS(T₂) = 2 WTS(A) = 0, RTS(A) = 1 Check: TS(T₂) = 2 > WTS(A) = 0 → OK But for write: TS(T₂) = 2 > RTS(A) = 1 → OK So W(A) is allowed After W(A): WTS(A) = max(WTS(A), TS(T₂)) = 2 #### 3. T₁: W(A) TS(T₁) = 1 WTS(A) = 2 (from T₂'s write) TS(T₁) = 1 < WTS(A) = 2 → Conflict! So T₁'s W(A) is rejected — it would be aborted under basic TO protocol. But in the schedule S, T₁'s W(A) does happen. Therefore, S is NOT possible under basic TO protocol. So A is incorrect. --- B. S is possible under THOMAS WRITE RULE Timestamp Ordering (TO) protocol.Thomas Write Rule is a modification of TO protocol: For a write operation: - If TS(T) < WTS(A) → abort - But if TS(T) < RTS(A) → ignore the write (do not abort, just skip it) - Otherwise, proceed So Thomas Write Rule allows overwriting if the transaction is older than the last read, but only if the write is not conflicting with a read. Let’s re-analyze T₁: W(A) TS(T₁) = 1 WTS(A) = 2 (from T₂'s write) So TS(T₁) < WTS(A) → aborted under basic TO But under Thomas Write Rule, we check: TS(T₁) < RTS(A)? RTS(A) = 1 (from T₁'s R(A)) So TS(T₁) = 1 < RTS(A) = 1? → No, 1 is not less than 1 → equal So TS(T₁) = RTS(A) → not less → so not ignored So Thomas Write Rule still aborts T₁'s W(A) Wait — let's double-check the rule. Thomas Write Rule: For a write operation: - If TS(T) < WTS(A) → abort - Else if TS(T) < RTS(A) → ignore (do not execute) - Else → execute So: TS(T₁) = 1, WTS(A) = 2 → 1 < 2 → aborted So even under Thomas Write Rule, T₁'s W(A) is aborted But in the schedule, it does happen. So S is NOT possible under Thomas Write Rule either? Wait — but let's check the order again. Wait — is T₁'s R(A) before T₂'s W(A)? Yes. So T₁ reads A, then T₂ writes A, then T₁ writes A. So T₁'s write is after T₂'s write. So T₁'s write is overwriting T₂'s write. But T₁'s timestamp is 1, T₂'s is 2 — so T₁ is older than T₂. So T₁'s write is older than T₂'s write — but T₂ wrote after T₁ read. So T₁'s write is not allowed under TO because it writes after a younger transaction (T₂) wrote. But under Thomas Write Rule, if a transaction writes after a younger transaction has read, it can be ignored. But in this case, T₂ did not read A — T₂ only wrote. So RTS(A) = 1 (from T₁'s R(A)) T₁'s W(A): TS(T₁) = 1, RTS(A) = 1 → TS(T₁) = RTS(A) → not less → so not ignored So T₁'s W(A) is aborted under Thomas Write Rule. So S is not possible under Thomas Write Rule either. But wait — maybe I made a mistake. Let’s recheck the Thomas Write Rule. Actually, the Thomas Write Rule says: > A write operation is allowed only if: > - TS(T) > WTS(A) → then write > - Else if TS(T) > RTS(A) → then write > - Else → ignore (do not execute) Wait — no, the rule is: > For a write operation: > - If TS(T) < WTS(A) → abort > - Else if TS(T) < RTS(A) → ignore (skip the write) > - Else → execute So in our case: T₁: W(A) TS(T₁) = 1 WTS(A) = 2 → 1 < 2 → aborted So T₁'s W(A) is aborted under Thomas Write Rule. So S is not possible under Thomas Write Rule. But the option says: B. S is possible under THOMAS WRITE RULE TO protocol. So B is incorrect. But wait — maybe the schedule is not possible under either TO or Thomas Write Rule. But let's check C and D. --- C. S is conflict serializable.Conflict serializability: Can we find a serial schedule equivalent? The operations: T₁: R(A), W(A) T₂: W(A) Conflicts: T₁: R(A) and T₂: W(A) → conflict (read-write on same data) T₂: W(A) and T₁: W(A) → conflict (write-write) So the conflict graph: T₁ → T₂: because T₁ reads A, then T₂ writes A → T₁ → T₂ T₂ → T₁: because T₂ writes A, then T₁ writes A → T₂ → T₁ So we have a cycle: T₁ → T₂ → T₁ Therefore, not conflict serializable So C is incorrect --- D. S is view serializable.View serializability: Two schedules are view equivalent if: The first read of each data item is by the same transaction The last write of each data item is by the same transaction The final value of each data item is the same Let’s check: First read of A: T₁ reads A → so first read is by T₁ Last write of A: T₁ writes A → so last write is by T₁ Final value of A: T₁'s write is the last write → so final value is from T₁ Now, consider the serial schedule T₂ → T₁: T₂: W(A) → T₁: R(A), W(A) In this schedule: First read of A: T₁ → same Last write of A: T₁ → same Final value: T₁ → same So view equivalent to T₂ → T₁ Now, is there any updated read? An updated read is when a transaction reads a value that was written by another transaction. In our schedule: T₁ reads A → but T₂ writes A after T₁ reads → so T₁ reads the initial value So T₁'s read is not an updated read So no updated read → so view serializable So D is correct --- Now, summarize:A: S is possible under basic TO → False (T₁'s W(A) is aborted) B: S is possible under Thomas Write Rule TO → False (T₁'s W(A) is aborted) C: S is conflict serializable → False (cycle in conflict graph) D: S is view serializable → True So the incorrect options are A, B, C But the question says: "which of the following is/are incorrect?" So A, B, C are incorrect. But you said: "According to me Option A and C are incorrect." But B is also incorrect. Let’s double-check B. Wait — is Thomas Write Rule different? Let’s recheck the Thomas Write Rule. Actually, Thomas Write Rule allows a write to be ignored if TS(T) < RTS(A) — i.e., if the transaction is older than the last read. But in our case: T₁: W(A) TS(T₁) = 1 RTS(A) = 1 (from T₁'s R(A)) So TS(T₁) = RTS(A) → not less → so not ignored And TS(T₁) < WTS(A) = 2 → so aborted So T₁'s W(A) is aborted → so S is not possible under Thomas Write Rule. So B is incorrect But wait — is there a mistake in the schedule? Let’s re-express the schedule: From the diagram: T₁: BEGIN, R(A), W(A), COMMIT T₂: BEGIN, W(A), COMMIT And the timeline shows: T₁: R(A) → then T₂: W(A) → then T₁: W(A) So T₁ reads A, then T₂ writes A, then T₁ writes A. So T₁'s write is after T₂'s write. But T₁ is older than T₂. So T₁'s write is not allowed under TO or Thomas Write Rule. So S is not possible under either. So A and B are incorrect But C is also incorrect — not conflict serializable D is correct So A, B, C are incorrect But the question is: "which of the following is/are incorrect?" So the answer should be A, B, C But you said: "According to me Option A and C are incorrect." You missed B. But let’s check if B could be correct. Wait — maybe Thomas Write Rule allows the write if it's not conflicting? No — the rule is clear. Alternatively, maybe the schedule is possible under Thomas Write Rule? Let’s simulate: T₁: R(A) → TS(T₁) = 1, WTS(A) = 0, RTS(A) = 0 → 1 > 0 → OK → set RTS(A) = 1 T₂: W(A) → TS(T₂) = 2, WTS(A) = 0 → 2 > 0 → OK → set WTS(A) = 2 T₁: W(A) → TS(T₁) = 1, WTS(A) = 2 → 1 < 2 → aborted So T₁'s W(A) is aborted → so S is not possible So B is incorrect --- Final Answer:The incorrect options are: A: S is possible under basic TO → False B: S is possible under Thomas Write Rule TO → False C: S is conflict serializable → False D: S is view serializable → True So A, B, C are incorrect But the question says: "which of the following is/are incorrect?" So the answer is A, B, C But you said: "According to me Option A and C are incorrect." You are missing B. But let’s check if B could be correct. Wait — maybe Thomas Write Rule allows the write if the transaction is older than the last read? But in this case, TS(T₁) = 1, RTS(A) = 1 → not less → so not ignored So no Alternatively, maybe the schedule is possible under Thomas Write Rule if we ignore the write? But the rule says: if TS(T) < RTS(A) → ignore But 1 < 1 is false → so not ignored So T₁'s W(A) is aborted So S is not possible So B is incorrect --- Conclusion:A: Incorrect B: Incorrect C: Incorrect D: Correct So the incorrect options are A, B, C You are correct that A and C are incorrect, but B is also incorrect. So your answer is incomplete. --- Final Answer:The incorrect options are A, B, and C. So the answer is: A, B, C are incorrect. — KG AI Mentor 🤖