1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: NormedSpace.norm_le_dual_bound
File: Mathlib/Analysis/NormedSpace/Dual.lean

tactic: by_cases h : x = 0
state_before: 𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
⊢ ‖x‖ ≤ M
state_after: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : x = 0
⊢ ‖x‖ ≤ M

case neg
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : ¬x = 0
⊢ ‖x‖ ≤ M

tactic: simp only [h, hMp, norm_zero]
state_before: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : x = 0
⊢ ‖x‖ ≤ M
state_after: no goals

tactic: obtain ⟨f, hf₁, hfx⟩ : ∃ f : E →L[𝕜] 𝕜, ‖f‖ = 1 ∧ f x = ‖x‖ := exists_dual_vector 𝕜 x h
state_before: case neg
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : ¬x = 0
⊢ ‖x‖ ≤ M
state_after: case neg.intro.intro
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : ¬x = 0
f : E →L[𝕜] 𝕜
hf₁ : ‖f‖ = 1
hfx : f x = ↑‖x‖
⊢ ‖x‖ ≤ M

tactic: calc
  ‖x‖ = ‖(‖x‖ : 𝕜)‖ := RCLike.norm_coe_norm.symm
  _ = ‖f x‖ := by rw [hfx]
  _ ≤ M * ‖f‖ := hM f
  _ = M := by rw [hf₁, mul_one]
state_before: case neg.intro.intro
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : ¬x = 0
f : E →L[𝕜] 𝕜
hf₁ : ‖f‖ = 1
hfx : f x = ↑‖x‖
⊢ ‖x‖ ≤ M
state_after: no goals

tactic: rw [hfx]
state_before: 𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : ¬x = 0
f : E →L[𝕜] 𝕜
hf₁ : ‖f‖ = 1
hfx : f x = ↑‖x‖
⊢ ‖↑‖x‖‖ = ‖f x‖
state_after: no goals

tactic: rw [hf₁, mul_one]
state_before: 𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
M : ℝ
hMp : 0 ≤ M
hM : ∀ (f : Dual 𝕜 E), ‖f x‖ ≤ M * ‖f‖
h : ¬x = 0
f : E →L[𝕜] 𝕜
hf₁ : ‖f‖ = 1
hfx : f x = ↑‖x‖
⊢ M * ‖f‖ = M
state_after: no goals
Theorem: CategoryTheory.Arrow.isIso_of_isIso_left_of_isIso_right
File: Mathlib/CategoryTheory/Comma/Arrow.lean

tactic: let inverse : g ⟶ f := ⟨inv ff.left, inv ff.right, (by simp)⟩
state_before: T : Type u
inst✝² : Category.{v, u} T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
⊢ ∃ inv, ff ≫ inv = 𝟙 f ∧ inv ≫ ff = 𝟙 g
state_after: T : Type u
inst✝² : Category.{v, u} T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
inverse : g ⟶ f := { left := inv ff.left, right := inv ff.right, w := ⋯ }
⊢ ∃ inv, ff ≫ inv = 𝟙 f ∧ inv ≫ ff = 𝟙 g

tactic: apply Exists.intro inverse
state_before: T : Type u
inst✝² : Category.{v, u} T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
inverse : g ⟶ f := { left := inv ff.left, right := inv ff.right, w := ⋯ }
⊢ ∃ inv, ff ≫ inv = 𝟙 f ∧ inv ≫ ff = 𝟙 g
state_after: T : Type u
inst✝² : Category.{v, u} T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
inverse : g ⟶ f := { left := inv ff.left, right := inv ff.right, w := ⋯ }
⊢ ff ≫ inverse = 𝟙 f ∧ inverse ≫ ff = 𝟙 g

tactic: aesop_cat
state_before: T : Type u
inst✝² : Category.{v, u} T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
inverse : g ⟶ f := { left := inv ff.left, right := inv ff.right, w := ⋯ }
⊢ ff ≫ inverse = 𝟙 f ∧ inverse ≫ ff = 𝟙 g
state_after: no goals

tactic: simp
state_before: T : Type u
inst✝² : Category.{v, u} T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
⊢ (𝟭 T).map (inv ff.left) ≫ f.hom = g.hom ≫ (𝟭 T).map (inv ff.right)
state_after: no goals
Theorem: Real.sinh_neg_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simpa only [sinh_zero] using @sinh_lt_sinh x 0
state_before: x y z : ℝ
⊢ sinh x < 0 ↔ x < 0
state_after: no goals
Theorem: Matrix.zpow_add_of_nonneg
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: obtain ⟨k, rfl⟩ := eq_ofNat_of_zero_le hm
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : 0 ≤ m
hn : 0 ≤ n
⊢ A ^ (m + n) = A ^ m * A ^ n
state_after: case intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : 0 ≤ n
k : ℕ
hm : 0 ≤ ↑k
⊢ A ^ (↑k + n) = A ^ ↑k * A ^ n

tactic: obtain ⟨l, rfl⟩ := eq_ofNat_of_zero_le hn
state_before: case intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : 0 ≤ n
k : ℕ
hm : 0 ≤ ↑k
⊢ A ^ (↑k + n) = A ^ ↑k * A ^ n
state_after: case intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
k : ℕ
hm : 0 ≤ ↑k
l : ℕ
hn : 0 ≤ ↑l
⊢ A ^ (↑k + ↑l) = A ^ ↑k * A ^ ↑l

tactic: rw [← Int.ofNat_add, zpow_natCast, zpow_natCast, zpow_natCast, pow_add]
state_before: case intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
k : ℕ
hm : 0 ≤ ↑k
l : ℕ
hn : 0 ≤ ↑l
⊢ A ^ (↑k + ↑l) = A ^ ↑k * A ^ ↑l
state_after: no goals
Theorem: Rat.sub.aux
File: .lake/packages/batteries/Batteries/Data/Rat/Basic.lean

tactic: have := add.aux a (-b) hg had hbd
state_before: a b : Rat
g ad bd : Nat
hg : g = a.den.gcd b.den
had : ad = a.den / g
hbd : bd = b.den / g
⊢ let den := ad * b.den;
  let num := a.num * ↑bd - b.num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den
state_after: a b : Rat
g ad bd : Nat
hg : g = a.den.gcd b.den
had : ad = a.den / g
hbd : bd = b.den / g
this :
  let den := ad * (-b).den;
  let num := a.num * ↑bd + (-b).num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den
⊢ let den := ad * b.den;
  let num := a.num * ↑bd - b.num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den

tactic: simp only [show (-b).num = -b.num from rfl, Int.neg_mul] at this
state_before: a b : Rat
g ad bd : Nat
hg : g = a.den.gcd b.den
had : ad = a.den / g
hbd : bd = b.den / g
this :
  let den := ad * (-b).den;
  let num := a.num * ↑bd + (-b).num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den
⊢ let den := ad * b.den;
  let num := a.num * ↑bd - b.num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den
state_after: a b : Rat
g ad bd : Nat
hg : g = a.den.gcd b.den
had : ad = a.den / g
hbd : bd = b.den / g
this : (a.num * ↑bd + -(b.num * ↑ad)).natAbs.gcd g = (a.num * ↑bd + -(b.num * ↑ad)).natAbs.gcd (ad * (-b).den)
⊢ let den := ad * b.den;
  let num := a.num * ↑bd - b.num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den

tactic: exact this
state_before: a b : Rat
g ad bd : Nat
hg : g = a.den.gcd b.den
had : ad = a.den / g
hbd : bd = b.den / g
this : (a.num * ↑bd + -(b.num * ↑ad)).natAbs.gcd g = (a.num * ↑bd + -(b.num * ↑ad)).natAbs.gcd (ad * (-b).den)
⊢ let den := ad * b.den;
  let num := a.num * ↑bd - b.num * ↑ad;
  num.natAbs.gcd g = num.natAbs.gcd den
state_after: no goals
Theorem: Part.elim_toOption
File: Mathlib/Data/Part.lean

tactic: split_ifs with h
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
⊢ a.toOption.elim b f = if h : a.Dom then f (a.get h) else b
state_after: case pos
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ a.toOption.elim b f = f (a.get h)

case neg
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ a.toOption.elim b f = b

tactic: rw [h.toOption]
state_before: case pos
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ a.toOption.elim b f = f (a.get h)
state_after: case pos
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ (Option.some (a.get h)).elim b f = f (a.get h)

tactic: rfl
state_before: case pos
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ (Option.some (a.get h)).elim b f = f (a.get h)
state_after: no goals

tactic: rw [Part.toOption_eq_none_iff.2 h]
state_before: case neg
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ a.toOption.elim b f = b
state_after: case neg
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ Option.none.elim b f = b

tactic: rfl
state_before: case neg
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ Option.none.elim b f = b
state_after: no goals
Theorem: hnot_bot
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [hnot_le_iff_codisjoint_left, codisjoint_bot, top_le_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b c a : α
⊢ ￢⊥ ≤ a ↔ ⊤ ≤ a
state_after: no goals
Theorem: SetTheory.PGame.birthday_zero
File: Mathlib/SetTheory/Game/Birthday.lean

tactic: simp [inferInstanceAs (IsEmpty PEmpty)]
state_before: ⊢ birthday 0 = 0
state_after: no goals
Theorem: Complex.abs_cpow_real
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [abs_cpow_of_imp] <;> simp
state_before: x : ℂ
y : ℝ
⊢ abs (x ^ ↑y) = abs x ^ y
state_after: no goals
Theorem: Finset.prod_diag
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: apply prod_nbij' Prod.fst (fun i ↦ (i, i)) <;> simp
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α × α → β
⊢ ∏ i ∈ s.diag, f i = ∏ i ∈ s, f (i, i)
state_after: no goals
Theorem: Set.image2_inter_union_subset_union
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image2_union_right]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∩ s') (t ∪ t') ⊆ image2 f s t ∪ image2 f s' t'
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∩ s') t ∪ image2 f (s ∩ s') t' ⊆ image2 f s t ∪ image2 f s' t'

tactic: exact
  union_subset_union (image2_subset_right inter_subset_left)
    (image2_subset_right inter_subset_right)
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∩ s') t ∪ image2 f (s ∩ s') t' ⊆ image2 f s t ∪ image2 f s' t'
state_after: no goals
Theorem: List.drop_take_succ_join_eq_getElem'
File: Mathlib/Data/List/Join.lean

tactic: have : (L.map length).take i = ((L.take (i + 1)).map length).take i := by
  simp [map_take, take_take, Nat.min_eq_left]
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
⊢ drop (Nat.sum (take i (map length L))) (take (Nat.sum (take (i + 1) (map length L))) L.join) = L[i]
state_after: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
this : take i (map length L) = take i (map length (take (i + 1) L))
⊢ drop (Nat.sum (take i (map length L))) (take (Nat.sum (take (i + 1) (map length L))) L.join) = L[i]

tactic: simp only [this, length_map, take_sum_join', drop_sum_join', drop_take_succ_eq_cons_getElem, h,
  join, append_nil]
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
this : take i (map length L) = take i (map length (take (i + 1) L))
⊢ drop (Nat.sum (take i (map length L))) (take (Nat.sum (take (i + 1) (map length L))) L.join) = L[i]
state_after: no goals

tactic: simp [map_take, take_take, Nat.min_eq_left]
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
⊢ take i (map length L) = take i (map length (take (i + 1) L))
state_after: no goals
Theorem: Associates.factors_mul
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
⊢ (a * b).factors = a.factors + b.factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors = a.factors + b.factors

tactic: refine eq_of_prod_eq_prod <| eq_of_factors_eq_factors ?_
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors = a.factors + b.factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors.prod.factors = (a.factors + b.factors).prod.factors

tactic: rw [prod_add, factors_prod, factors_prod, factors_prod]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors.prod.factors = (a.factors + b.factors).prod.factors
state_after: no goals
Theorem: Filter.map_eq_bot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← empty_mem_iff_bot, ← empty_mem_iff_bot]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ map m f = ⊥ → f = ⊥
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ ∅ ∈ map m f → ∅ ∈ f

tactic: exact id
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ ∅ ∈ map m f → ∅ ∈ f
state_after: no goals

tactic: simp only [h, map_bot]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : f = ⊥
⊢ map m f = ⊥
state_after: no goals
Theorem: Mathlib.Tactic.Abel.term_atomg
File: Mathlib/Tactic/Abel.lean

tactic: simp [termg]
state_before: α : Type u_1
inst✝ : AddCommGroup α
x : α
⊢ x = termg 1 x 0
state_after: no goals
Theorem: Order.le_succ_iff_eq_or_le
File: Mathlib/Order/SuccPred/Basic.lean

tactic: by_cases hb : IsMax b
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
hb : IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b

case neg
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
hb : ¬IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b

tactic: rw [hb.succ_eq, or_iff_right_of_imp le_of_eq]
state_before: case pos
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
hb : IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b
state_after: no goals

tactic: rw [← lt_succ_iff_of_not_isMax hb, le_iff_eq_or_lt]
state_before: case neg
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
hb : ¬IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.comap_map
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

tactic: rw [comap_apply, map_apply, hf.preimage_image]
state_before: α : Type u_1
β✝ : Type u_2
m✝ : OuterMeasure α
β : Type u_3
f : α → β
hf : Injective f
m : OuterMeasure α
s : Set α
⊢ ((comap f) ((map f) m)) s = m s
state_after: no goals
Theorem: List.findIdxs_cons_aux
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction xs generalizing s with
| nil => rfl
| cons x xs ih =>
  simp only [foldrIdx]
  split <;> simp [ih]
state_before: α : Type u_1
xs : List α
s : Nat
p : α → Bool
⊢ foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs s =
    map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs s)
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
p : α → Bool
s : Nat
⊢ foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] [] s =
    map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] [] s)
state_after: no goals

tactic: simp only [foldrIdx]
state_before: case cons
α : Type u_1
p : α → Bool
x : α
xs : List α
ih :
  ∀ {s : Nat},
    foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs s =
      map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs s)
s : Nat
⊢ foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] (x :: xs) s =
    map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] (x :: xs) s)
state_after: case cons
α : Type u_1
p : α → Bool
x : α
xs : List α
ih :
  ∀ {s : Nat},
    foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs s =
      map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs s)
s : Nat
⊢ (if p x = true then (s + 1) :: foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs (s + 1)
    else foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs (s + 1)) =
    map (fun x => x + 1)
      (if p x = true then s :: foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs (s + 1)
      else foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs (s + 1))

tactic: split <;> simp [ih]
state_before: case cons
α : Type u_1
p : α → Bool
x : α
xs : List α
ih :
  ∀ {s : Nat},
    foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs s =
      map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs s)
s : Nat
⊢ (if p x = true then (s + 1) :: foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs (s + 1)
    else foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs (s + 1)) =
    map (fun x => x + 1)
      (if p x = true then s :: foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs (s + 1)
      else foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs (s + 1))
state_after: no goals
Theorem: MeasurableSet.iInter
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

tactic: rw [compl_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
inst✝ : Countable ι
f : ι → Set α
h : ∀ (b : ι), MeasurableSet (f b)
⊢ MeasurableSet (⋂ b, f b)ᶜ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
inst✝ : Countable ι
f : ι → Set α
h : ∀ (b : ι), MeasurableSet (f b)
⊢ MeasurableSet (⋃ i, (f i)ᶜ)

tactic: exact .iUnion fun b => (h b).compl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
inst✝ : Countable ι
f : ι → Set α
h : ∀ (b : ι), MeasurableSet (f b)
⊢ MeasurableSet (⋃ i, (f i)ᶜ)
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.normalize_eq_of_nonzero
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: simp only [μ.self_eq_mass_mul_normalize, μ.mass_nonzero_iff.mpr nonzero, inv_mul_cancel_left₀,
  Ne, not_false_iff]
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
s : Set Ω
⊢ μ.normalize s = μ.mass⁻¹ * μ s
state_after: no goals
Theorem: Matrix.conjTranspose_eq_zero
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [← conjTranspose_inj (A := M), conjTranspose_zero]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : Matrix m n α
⊢ Mᴴ = 0 ↔ M = 0
state_after: no goals
Theorem: Multiset.Nodup.product
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [List.Nodup.product d₁ d₂]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
b : β
s : Multiset α
t : Multiset β
l₁ : List α
l₂ : List β
d₁ : Nodup ⟦l₁⟧
d₂ : Nodup ⟦l₂⟧
⊢ (⟦l₁⟧ ×ˢ ⟦l₂⟧).Nodup
state_after: no goals
Theorem: Int.two_not_dvd_two_mul_add_one
File: Mathlib/Algebra/Group/Int.lean

tactic: simp [add_emod]
state_before: u v m n✝ n : ℤ
⊢ ¬2 ∣ 2 * n + 1
state_after: no goals
Theorem: LieSubmodule.coeSubmodule_eq_top_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← coe_toSubmodule_eq_iff, top_coeSubmodule]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ ↑N = ⊤ ↔ N = ⊤
state_after: no goals
Theorem: List.insert_eq_ite
File: Mathlib/Data/List/Infix.lean

tactic: simp only [← elem_iff]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ insert a l = if a ∈ l then l else a :: l
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ insert a l = if elem a l = true then l else a :: l

tactic: rfl
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ insert a l = if elem a l = true then l else a :: l
state_after: no goals
Theorem: Matrix.det_mvPolynomialX_ne_zero
File: Mathlib/LinearAlgebra/Matrix/MvPolynomial.lean

tactic: intro h_det
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ (mvPolynomialX m m R).det ≠ 0
state_after: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
⊢ False

tactic: have := congr_arg Matrix.det (mvPolynomialX_mapMatrix_eval (1 : Matrix m m R))
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
⊢ False
state_after: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : ((MvPolynomial.eval fun p => 1 p.1 p.2).mapMatrix (mvPolynomialX m m R)).det = det 1
⊢ False

tactic: rw [det_one, ← RingHom.map_det, h_det, RingHom.map_zero] at this
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : ((MvPolynomial.eval fun p => 1 p.1 p.2).mapMatrix (mvPolynomialX m m R)).det = det 1
⊢ False
state_after: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : 0 = 1
⊢ False

tactic: exact zero_ne_one this
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : 0 = 1
⊢ False
state_after: no goals