1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Stream'.WSeq.LiftRel.refl
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [← h]
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Computation.LiftRel (LiftRelO R fun x x_1 => x = x_1) s.destruct t.destruct
state_after: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Computation.LiftRel (LiftRelO R fun x x_1 => x = x_1) s.destruct s.destruct

tactic: apply Computation.LiftRel.refl
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Computation.LiftRel (LiftRelO R fun x x_1 => x = x_1) s.destruct s.destruct
state_after: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Reflexive (LiftRelO R fun x x_1 => x = x_1)

tactic: intro a
state_before: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ Reflexive (LiftRelO R fun x x_1 => x = x_1)
state_after: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
a : Option (α × WSeq α)
⊢ LiftRelO R (fun x x_1 => x = x_1) a a

tactic: cases' a with a
state_before: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
a : Option (α × WSeq α)
⊢ LiftRelO R (fun x x_1 => x = x_1) a a
state_after: case H.none
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ LiftRelO R (fun x x_1 => x = x_1) none none

case H.some
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
a : α × WSeq α
⊢ LiftRelO R (fun x x_1 => x = x_1) (some a) (some a)

tactic: simp
state_before: case H.none
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
⊢ LiftRelO R (fun x x_1 => x = x_1) none none
state_after: no goals

tactic: cases a
state_before: case H.some
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
a : α × WSeq α
⊢ LiftRelO R (fun x x_1 => x = x_1) (some a) (some a)
state_after: case H.some.mk
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
fst✝ : α
snd✝ : WSeq α
⊢ LiftRelO R (fun x x_1 => x = x_1) (some (fst✝, snd✝)) (some (fst✝, snd✝))

tactic: simp only [LiftRelO, and_true]
state_before: case H.some.mk
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
fst✝ : α
snd✝ : WSeq α
⊢ LiftRelO R (fun x x_1 => x = x_1) (some (fst✝, snd✝)) (some (fst✝, snd✝))
state_after: case H.some.mk
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
fst✝ : α
snd✝ : WSeq α
⊢ R fst✝ fst✝

tactic: apply H
state_before: case H.some.mk
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Reflexive R
s✝ s t : WSeq α
h : s = t
fst✝ : α
snd✝ : WSeq α
⊢ R fst✝ fst✝
state_after: no goals
Theorem: Nat.log_eq_one_iff'
File: Mathlib/Data/Nat/Log.lean

tactic: rw [log_eq_iff (Or.inl Nat.one_ne_zero), Nat.pow_add, Nat.pow_one]
state_before: b n : ℕ
⊢ log b n = 1 ↔ b ≤ n ∧ n < b * b
state_after: no goals
Theorem: Cardinal.lift_mk_shrink''
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_umax', lift_mk_shrink.{max u v, v, 0} α, ← lift_umax, lift_id]
state_before: α✝ β : Type u
α : Type (max u v)
inst✝ : Small.{v, max u v} α
⊢ lift.{u, v} #(Shrink.{v, max u v} α) = #α
state_after: no goals
Theorem: isClosed_range_inl
File: Mathlib/Topology/Constructions.lean

tactic: rw [← isOpen_compl_iff, compl_range_inl]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
⊢ IsClosed (range inl)
state_after: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
⊢ IsOpen (range inr)

tactic: exact isOpen_range_inr
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
⊢ IsOpen (range inr)
state_after: no goals
Theorem: sign_nonpos_iff
File: Mathlib/Data/Sign.lean

tactic: rcases lt_trichotomy 0 a with (h | h | h)
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
⊢ sign a ≤ 0 ↔ a ≤ 0
state_after: case inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 < a
⊢ sign a ≤ 0 ↔ a ≤ 0

case inr.inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 = a
⊢ sign a ≤ 0 ↔ a ≤ 0

case inr.inr
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : a < 0
⊢ sign a ≤ 0 ↔ a ≤ 0

tactic: simp [h, h.not_le]
state_before: case inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 < a
⊢ sign a ≤ 0 ↔ a ≤ 0
state_after: no goals

tactic: simp [← h]
state_before: case inr.inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 = a
⊢ sign a ≤ 0 ↔ a ≤ 0
state_after: no goals

tactic: simp [h, h.le]
state_before: case inr.inr
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : a < 0
⊢ sign a ≤ 0 ↔ a ≤ 0
state_after: no goals
Theorem: Function.Periodic.add_const
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [add_right_comm] using h (x + a)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (x + a)) (x + c) = (fun x => f (x + a)) x
state_after: no goals
Theorem: Finset.prod_Ico_mul_eq_prod_Icc
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [mul_comm, mul_prod_Ico_eq_prod_Icc h]
state_before: α : Type u_1
M : Type u_2
inst✝² : PartialOrder α
inst✝¹ : CommMonoid M
f : α → M
a b : α
inst✝ : LocallyFiniteOrder α
h : a ≤ b
⊢ (∏ x ∈ Ico a b, f x) * f b = ∏ x ∈ Icc a b, f x
state_after: no goals
Theorem: FirstOrder.Language.Ultraproduct.realize_formula_cast
File: Mathlib/ModelTheory/Ultraproducts.lean

tactic: simp_rw [Formula.Realize, ← boundedFormula_realize_cast φ x, iff_eq_eq]
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝¹ : (a : α) → L.Structure (M a)
inst✝ : ∀ (a : α), Nonempty (M a)
β : Type u_3
φ : L.Formula β
x : β → (a : α) → M a
⊢ (φ.Realize fun i => Quotient.mk' (x i)) ↔ ∀ᶠ (a : α) in ↑u, φ.Realize fun i => x i a
state_after: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝¹ : (a : α) → L.Structure (M a)
inst✝ : ∀ (a : α), Nonempty (M a)
β : Type u_3
φ : L.Formula β
x : β → (a : α) → M a
⊢ BoundedFormula.Realize φ (fun i => Quotient.mk' (x i)) default =
    BoundedFormula.Realize φ (fun i => Quotient.mk' (x i)) fun i => Quotient.mk' fun a => default i

tactic: exact congr rfl (Subsingleton.elim _ _)
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝¹ : (a : α) → L.Structure (M a)
inst✝ : ∀ (a : α), Nonempty (M a)
β : Type u_3
φ : L.Formula β
x : β → (a : α) → M a
⊢ BoundedFormula.Realize φ (fun i => Quotient.mk' (x i)) default =
    BoundedFormula.Realize φ (fun i => Quotient.mk' (x i)) fun i => Quotient.mk' fun a => default i
state_after: no goals
Theorem: MulAction.orbitRel.quotient_eq_of_quotient_subgroup_eq
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: rw [@Quotient.eq] at h ⊢
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : ⟦a⟧ = ⟦b⟧
⊢ ⟦a⟧ = ⟦b⟧
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : a ≈ b
⊢ a ≈ b

tactic: exact mem_orbit_of_mem_orbit_subgroup h
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : a ≈ b
⊢ a ≈ b
state_after: no goals
Theorem: Zsqrtd.norm_eq_one_iff'
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [← norm_eq_one_iff, ← Int.natCast_inj, Int.natAbs_of_nonneg (norm_nonneg hd z), Int.ofNat_one]
state_before: d✝ d : ℤ
hd : d ≤ 0
z : ℤ√d
⊢ z.norm = 1 ↔ IsUnit z
state_after: no goals
Theorem: Finset.Icc_diff_Ico_self
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simp [← coe_inj, h]
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ Icc a b \ Ico a b = {b}
state_after: no goals
Theorem: TypeVec.subtypeVal_toSubtype'
File: Mathlib/Data/TypeVec.lean

tactic: ext i x
state_before: n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
⊢ subtypeVal r ⊚ toSubtype' r = fun i x => prod.mk i (↑x).1 (↑x).2
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : (fun i => { x // ofRepeat (r i (prod.mk i x.1 x.2)) }) i
⊢ (subtypeVal r ⊚ toSubtype' r) i x = prod.mk i (↑x).1 (↑x).2

tactic: induction i <;> dsimp only [id, toSubtype', comp, subtypeVal, prod.mk] at *
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : (fun i => { x // ofRepeat (r i (prod.mk i x.1 x.2)) }) i
⊢ (subtypeVal r ⊚ toSubtype' r) i x = prod.mk i (↑x).1 (↑x).2
state_after: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ :
  ∀ {α : TypeVec.{u_1} n✝} (r : α ⊗ α ⟹ repeat n✝ Prop) (x : { x // ofRepeat (r a✝ (prod.mk a✝ x.1 x.2)) }),
    subtypeVal r a✝ (toSubtype' r a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
α : TypeVec.{u_1} (n✝ + 1)
r : α ⊗ α ⟹ repeat (n✝ + 1) Prop
x : { x // ofRepeat (r a✝.fs (prod.mk a✝.fs x.1 x.2)) }
⊢ subtypeVal (dropFun r) a✝ (toSubtype' (dropFun r) a✝ x) = prod.mk a✝ (↑x).1 (↑x).2

tactic: simp [*]
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ :
  ∀ {α : TypeVec.{u_1} n✝} (r : α ⊗ α ⟹ repeat n✝ Prop) (x : { x // ofRepeat (r a✝ (prod.mk a✝ x.1 x.2)) }),
    subtypeVal r a✝ (toSubtype' r a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
α : TypeVec.{u_1} (n✝ + 1)
r : α ⊗ α ⟹ repeat (n✝ + 1) Prop
x : { x // ofRepeat (r a✝.fs (prod.mk a✝.fs x.1 x.2)) }
⊢ subtypeVal (dropFun r) a✝ (toSubtype' (dropFun r) a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
state_after: no goals
Theorem: MonoidHom.prod_unique
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp only [prod_apply, coe_fst, coe_snd, comp_apply]
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : M →* N × P
x : M
⊢ (((fst N P).comp f).prod ((snd N P).comp f)) x = f x
state_after: no goals
Theorem: Filter.tendsto_const_mul_atBot_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [neg_mul, tendsto_neg_atTop_iff] using tendsto_const_mul_atTop_of_pos (neg_pos.2 hr)
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atTop
state_after: no goals
Theorem: SetTheory.PGame.bddAbove_range_of_small
File: Mathlib/SetTheory/Game/PGame.lean

tactic: let x : PGame.{u} := ⟨Σ i, (f $ (equivShrink.{u} ι).symm i).LeftMoves, PEmpty,
  fun x ↦ moveLeft _ x.2, PEmpty.elim⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
⊢ BddAbove (Set.range f)
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
⊢ BddAbove (Set.range f)

tactic: refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
⊢ BddAbove (Set.range f)
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ f i ≤ x

tactic: rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ f i ≤ x
state_after: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ (∀ (i_1 : (f ((equivShrink ι).symm ((equivShrink ι) i))).LeftMoves),
      (f ((equivShrink ι).symm ((equivShrink ι) i))).moveLeft i_1 ⧏ x) ∧
    ∀ (j : x.RightMoves), f ((equivShrink ι).symm ((equivShrink ι) i)) ⧏ x.moveRight j

tactic: simpa [x] using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩
state_before: xl xr : Type u
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → PGame
x : PGame :=
  mk ((i : Shrink.{u, u_1} ι) × (f ((equivShrink ι).symm i)).LeftMoves) PEmpty.{u + 1}
    (fun x => (f ((equivShrink ι).symm x.fst)).moveLeft x.snd) PEmpty.elim
i : ι
⊢ (∀ (i_1 : (f ((equivShrink ι).symm ((equivShrink ι) i))).LeftMoves),
      (f ((equivShrink ι).symm ((equivShrink ι) i))).moveLeft i_1 ⧏ x) ∧
    ∀ (j : x.RightMoves), f ((equivShrink ι).symm ((equivShrink ι) i)) ⧏ x.moveRight j
state_after: no goals
Theorem: CategoryTheory.Functor.preservesMonomorphisms_of_map_exact
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: letI := preservesZeroMorphisms_of_map_exact L h
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
⊢ Mono (L.map f)
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
this : L.PreservesZeroMorphisms := preservesZeroMorphisms_of_map_exact L h
⊢ Mono (L.map f)

tactic: apply ((tfae_mono (L.obj 0) (L.map f)).out 2 0).mp
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
this : L.PreservesZeroMorphisms := preservesZeroMorphisms_of_map_exact L h
⊢ Mono (L.map f)
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
this : L.PreservesZeroMorphisms := preservesZeroMorphisms_of_map_exact L h
⊢ Exact 0 (L.map f)

tactic: rw [← L.map_zero]
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
this : L.PreservesZeroMorphisms := preservesZeroMorphisms_of_map_exact L h
⊢ Exact 0 (L.map f)
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
this : L.PreservesZeroMorphisms := preservesZeroMorphisms_of_map_exact L h
⊢ Exact (L.map 0) (L.map f)

tactic: exact h (((tfae_mono 0 f).out 0 2).mp hf)
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Mono f
this : L.PreservesZeroMorphisms := preservesZeroMorphisms_of_map_exact L h
⊢ Exact (L.map 0) (L.map f)
state_after: no goals
Theorem: Finset.sup'_lt_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_lt_coe, coe_sup', Finset.sup_lt_iff (WithBot.bot_lt_coe a)]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ s.sup' H f < a ↔ ∀ i ∈ s, f i < a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ (∀ b ∈ s, (WithBot.some ∘ f) b < ↑a) ↔ ∀ i ∈ s, f i < a

tactic: exact forall₂_congr (fun _ _ => WithBot.coe_lt_coe)
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ (∀ b ∈ s, (WithBot.some ∘ f) b < ↑a) ↔ ∀ i ∈ s, f i < a
state_after: no goals
Theorem: StrictConvexOn.secant_strict_mono_aux3
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have hyz' : 0 < z - y := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)

tactic: have hxz' : 0 < z - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)

tactic: rw [div_lt_div_iff hxz' hyz']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) * (z - y) < (f z - f y) * (z - x)

tactic: linarith only [hf.secant_strict_mono_aux1 hx hz hxy hyz]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) * (z - y) < (f z - f y) * (z - x)
state_after: no goals

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ 0 < z - y
state_after: no goals

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ 0 < z - x
state_after: no goals
Theorem: derivWithin_congr_set'
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp only [derivWithin, fderivWithin_congr_set' y h]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
y : 𝕜
h : s =ᶠ[𝓝[{y}ᶜ] x] t
⊢ derivWithin f s x = derivWithin f t x
state_after: no goals
Theorem: summable_iff_not_tendsto_nat_atTop_of_nonneg
File: Mathlib/Topology/Algebra/InfiniteSum/Real.lean

tactic: rw [← not_iff_not, Classical.not_not, not_summable_iff_tendsto_nat_atTop_of_nonneg hf]
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
f : ℕ → ℝ
hf : ∀ (n : ℕ), 0 ≤ f n
⊢ Summable f ↔ ¬Tendsto (fun n => ∑ i ∈ range n, f i) atTop atTop
state_after: no goals
Theorem: sameRay_smul_right_iff_of_ne
File: Mathlib/LinearAlgebra/Ray.lean

tactic: simp only [sameRay_smul_right_iff, hv, or_false_iff, hr.symm.le_iff_lt]
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
v : M
hv : v ≠ 0
r : R
hr : r ≠ 0
⊢ SameRay R v (r • v) ↔ 0 < r
state_after: no goals
Theorem: Fin.map_valEmbedding_Ico
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: simp [Ico_eq_finset_subtype, Finset.fin, Finset.map_map]
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ico a b) = Ico ↑a ↑b
state_after: no goals
Theorem: AddCommGroup.ModEq.sub_iff_left
File: Mathlib/Algebra/ModEq.lean

tactic: simp [sub_sub_sub_comm, hm, sub_smul, ModEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a₁ ≡ b₁ [PMOD p]
m : ℤ
hm : b₁ - a₁ = m • p
⊢ (∃ b, b₁ - b₂ - (a₁ - a₂) = (Equiv.subLeft m).symm.symm b • p) ↔ a₂ ≡ b₂ [PMOD p]
state_after: no goals
Theorem: Num.castNum_or
File: Mathlib/Data/Num/Lemmas.lean

tactic: apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
 intros <;> (try cases_type* Bool) <;> rfl
state_before: α : Type u_1
⊢ ∀ (m n : Num), ↑(m ||| n) = ↑m ||| ↑n
state_after: no goals

tactic: try cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit a✝ m✝).lor (PosNum.bit b✝ n✝)) = bit (a✝ || b✝) (pos (m✝.lor n✝))
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit false m✝).lor (PosNum.bit false n✝)) = bit (false || false) (pos (m✝.lor n✝))

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit false m✝).lor (PosNum.bit true n✝)) = bit (false || true) (pos (m✝.lor n✝))

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit true m✝).lor (PosNum.bit false n✝)) = bit (true || false) (pos (m✝.lor n✝))

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit true m✝).lor (PosNum.bit true n✝)) = bit (true || true) (pos (m✝.lor n✝))

tactic: cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit a✝ m✝).lor (PosNum.bit b✝ n✝)) = bit (a✝ || b✝) (pos (m✝.lor n✝))
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit false m✝).lor (PosNum.bit false n✝)) = bit (false || false) (pos (m✝.lor n✝))

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit false m✝).lor (PosNum.bit true n✝)) = bit (false || true) (pos (m✝.lor n✝))

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit true m✝).lor (PosNum.bit false n✝)) = bit (true || false) (pos (m✝.lor n✝))

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ pos ((PosNum.bit true m✝).lor (PosNum.bit true n✝)) = bit (true || true) (pos (m✝.lor n✝))