1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.div_lt_one_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: simp only [← Nat.not_le, one_le_div_iff hb]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a / b < 1 ↔ a < b
state_after: no goals
Theorem: LinearEquiv.conj_exact_iff_exact
File: Mathlib/Algebra/Exact.lean

tactic: simp_rw [exact_iff, ker_comp, ← e.map_eq_comap, range_comp]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : AddCommMonoid N'
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid P'
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R N
inst✝² : Module R N'
inst✝¹ : Module R P
inst✝ : Module R P'
f : M →ₗ[R] N
g : N →ₗ[R] P
e : N ≃ₗ[R] N'
⊢ Exact ⇑(↑e ∘ₗ f) ⇑(g ∘ₗ ↑e.symm) ↔ Exact ⇑f ⇑g
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : AddCommMonoid N'
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid P'
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R N
inst✝² : Module R N'
inst✝¹ : Module R P
inst✝ : Module R P'
f : M →ₗ[R] N
g : N →ₗ[R] P
e : N ≃ₗ[R] N'
⊢ Submodule.map (↑e) (ker g) = Submodule.map (↑e) (range f) ↔ ker g = range f

tactic: exact (Submodule.map_injective_of_injective e.injective).eq_iff
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : AddCommMonoid N'
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid P'
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R N
inst✝² : Module R N'
inst✝¹ : Module R P
inst✝ : Module R P'
f : M →ₗ[R] N
g : N →ₗ[R] P
e : N ≃ₗ[R] N'
⊢ Submodule.map (↑e) (ker g) = Submodule.map (↑e) (range f) ↔ ker g = range f
state_after: no goals
Theorem: MultilinearMap.mkPiRing_eq_zero_iff
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: rw [← mkPiRing_zero, mkPiRing_eq_iff]
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin n.succ) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
z : M₂
⊢ MultilinearMap.mkPiRing R ι z = 0 ↔ z = 0
state_after: no goals
Theorem: Units.mk0_mul
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: ext
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
x y : G₀
hxy : x * y ≠ 0
⊢ mk0 (x * y) hxy = mk0 x ⋯ * mk0 y ⋯
state_after: case a
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
x y : G₀
hxy : x * y ≠ 0
⊢ ↑(mk0 (x * y) hxy) = ↑(mk0 x ⋯ * mk0 y ⋯)

tactic: rfl
state_before: case a
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
x y : G₀
hxy : x * y ≠ 0
⊢ ↑(mk0 (x * y) hxy) = ↑(mk0 x ⋯ * mk0 y ⋯)
state_after: no goals
Theorem: convexOn_rpow
File: Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean

tactic: rcases eq_or_lt_of_le hp with (rfl | hp)
state_before: p : ℝ
hp : 1 ≤ p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p
state_after: case inl
hp : 1 ≤ 1
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ 1

case inr
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p

tactic: exact (strictConvexOn_rpow hp).convexOn
state_before: case inr
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p
state_after: no goals

tactic: simpa using convexOn_id (convex_Ici _)
state_before: case inl
hp : 1 ≤ 1
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ 1
state_after: no goals
Theorem: sub_pow_expChar_pow_of_commute
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: cases' hR with _ _ hprime _
state_before: R : Type u
inst✝ : Ring R
q : ℕ
hR : ExpChar R q
n : ℕ
x y : R
h : Commute x y
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
state_after: case zero
R : Type u
inst✝¹ : Ring R
n : ℕ
x y : R
h : Commute x y
inst✝ : CharZero R
⊢ (x - y) ^ 1 ^ n = x ^ 1 ^ n - y ^ 1 ^ n

case prime
R : Type u
inst✝ : Ring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n

tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : Ring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
state_after: case prime
R : Type u
inst✝ : Ring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n

tactic: exact sub_pow_char_pow_of_commute R x y h
state_before: case prime
R : Type u
inst✝ : Ring R
q n : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
state_after: no goals

tactic: simp only [one_pow, pow_one]
state_before: case zero
R : Type u
inst✝¹ : Ring R
n : ℕ
x y : R
h : Commute x y
inst✝ : CharZero R
⊢ (x - y) ^ 1 ^ n = x ^ 1 ^ n - y ^ 1 ^ n
state_after: no goals
Theorem: rank_add_rank_le_rank_prod
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: convert ← lift_rank_add_lift_rank_le_rank_prod R M M₁ <;> apply lift_id
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁸ : Ring R
inst✝⁷ : CommRing S
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Nontrivial R
⊢ Module.rank R M + Module.rank R M₁ ≤ Module.rank R (M × M₁)
state_after: no goals
Theorem: IntermediateField.finrank_adjoin_simple_eq_one_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [finrank_adjoin_eq_one_iff]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ finrank F ↥F⟮α⟯ = 1 ↔ α ∈ ⊥
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ {α} ⊆ ↑⊥ ↔ α ∈ ⊥

tactic: exact Set.singleton_subset_iff
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ {α} ⊆ ↑⊥ ↔ α ∈ ⊥
state_after: no goals
Theorem: inv_nhdsWithin_Ioi_zero
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: rw [← inv_atTop₀, inv_inv]
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
⊢ (𝓝[>] 0)⁻¹ = atTop
state_after: no goals
Theorem: CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left_aux
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [← homEquiv_naturality_right, ← Equiv.eq_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ (adj.homEquiv X' (F.obj X)) (F.map f) ≫ G.map g = f ≫ (adj.homEquiv X Y) g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)
state_after: no goals
Theorem: norm_jacobiTheta₂'_term_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

tactic: rw [jacobiTheta₂'_term, norm_mul]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖jacobiTheta₂'_term n z τ‖ ≤ 2 * π * ↑|n| * rexp (-π * (T * ↑n ^ 2 - 2 * S * ↑|n|))
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖2 * ↑π * I * ↑n‖ * ‖jacobiTheta₂_term n z τ‖ ≤ 2 * π * ↑|n| * rexp (-π * (T * ↑n ^ 2 - 2 * S * ↑|n|))

tactic: refine mul_le_mul (le_of_eq ?_) (norm_jacobiTheta₂_term_le hT hz hτ n)
  (norm_nonneg _) (by positivity)
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖2 * ↑π * I * ↑n‖ * ‖jacobiTheta₂_term n z τ‖ ≤ 2 * π * ↑|n| * rexp (-π * (T * ↑n ^ 2 - 2 * S * ↑|n|))
state_after: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖2 * ↑π * I * ↑n‖ = 2 * π * ↑|n|

tactic: simp only [norm_mul, Complex.norm_eq_abs, Complex.abs_two, abs_I,
  Complex.abs_of_nonneg pi_pos.le, abs_intCast, mul_one, Int.cast_abs]
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ ‖2 * ↑π * I * ↑n‖ = 2 * π * ↑|n|
state_after: no goals

tactic: positivity
state_before: S T : ℝ
hT : 0 < T
z τ : ℂ
hz : |z.im| ≤ S
hτ : T ≤ τ.im
n : ℤ
⊢ 0 ≤ 2 * π * ↑|n|
state_after: no goals
Theorem: Complex.div_intCast_re
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [div_intCast]
state_before: z : ℂ
n : ℤ
⊢ (z / ↑n).re = z.re / ↑n
state_after: no goals
Theorem: Filter.EventuallyLE.mul_le_mul
File: Mathlib/Order/Filter/Ring.lean

tactic: filter_upwards [hf, hg, hg₀, hf₀] with x using _root_.mul_le_mul
state_before: α : Type u
β : Type v
inst✝³ : MulZeroClass β
inst✝² : PartialOrder β
inst✝¹ : PosMulMono β
inst✝ : MulPosMono β
l : Filter α
f₁ f₂ g₁ g₂ : α → β
hf : f₁ ≤ᶠ[l] f₂
hg : g₁ ≤ᶠ[l] g₂
hg₀ : 0 ≤ᶠ[l] g₁
hf₀ : 0 ≤ᶠ[l] f₂
⊢ f₁ * g₁ ≤ᶠ[l] f₂ * g₂
state_after: no goals
Theorem: Matrix.fromRows_mul_fromColumns
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

tactic: ext (_ | _) (_ | _) <;> simp
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
B₁ : Matrix n n₁ R
B₂ : Matrix n n₂ R
⊢ A₁.fromRows A₂ * B₁.fromColumns B₂ = fromBlocks (A₁ * B₁) (A₁ * B₂) (A₂ * B₁) (A₂ * B₂)
state_after: no goals
Theorem: subset_of_subset_of_eq
File: Mathlib/Order/RelClasses.lean

tactic: rwa [← hbc]
state_before: α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : HasSubset α
a b c : α
hab : a ⊆ b
hbc : b = c
⊢ a ⊆ c
state_after: no goals
Theorem: Filter.not_eventually
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [Filter.Frequently]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
⊢ (¬∀ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, ¬p x
state_after: no goals
Theorem: Cardinal.aleph_mul_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [Cardinal.mul_eq_max (aleph0_le_aleph o₁) (aleph0_le_aleph o₂), max_aleph_eq]
state_before: o₁ o₂ : Ordinal.{u_1}
⊢ aleph o₁ * aleph o₂ = aleph (max o₁ o₂)
state_after: no goals
Theorem: Batteries.DList.toList_append
File: Mathlib/Data/DList/Defs.lean

tactic: cases' l₁ with _ l₁_invariant
state_before: α : Type u
l₁ l₂ : DList α
⊢ (l₁.append l₂).toList = l₁.toList ++ l₂.toList
state_after: case mk
α : Type u
l₂ : DList α
apply✝ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ ({ apply := apply✝, invariant := l₁_invariant }.append l₂).toList =
    { apply := apply✝, invariant := l₁_invariant }.toList ++ l₂.toList

tactic: cases' l₂
state_before: case mk
α : Type u
l₂ : DList α
apply✝ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ ({ apply := apply✝, invariant := l₁_invariant }.append l₂).toList =
    { apply := apply✝, invariant := l₁_invariant }.toList ++ l₂.toList
state_after: case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ ({ apply := apply✝¹, invariant := l₁_invariant }.append { apply := apply✝, invariant := invariant✝ }).toList =
    { apply := apply✝¹, invariant := l₁_invariant }.toList ++ { apply := apply✝, invariant := invariant✝ }.toList

tactic: simp
state_before: case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ ({ apply := apply✝¹, invariant := l₁_invariant }.append { apply := apply✝, invariant := invariant✝ }).toList =
    { apply := apply✝¹, invariant := l₁_invariant }.toList ++ { apply := apply✝, invariant := invariant✝ }.toList
state_after: case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝¹ (apply✝ []) = apply✝¹ [] ++ apply✝ []

tactic: rw [l₁_invariant]
state_before: case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝¹ (apply✝ []) = apply✝¹ [] ++ apply✝ []
state_after: no goals
Theorem: mem_closure_iff_comap_neBot
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [mem_closure_iff_nhds, comap_neBot_iff, Set.inter_nonempty_iff_exists_right,
  SetCoe.exists, exists_prop]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ x ∈ closure s ↔ (comap Subtype.val (𝓝 x)).NeBot
state_after: no goals
Theorem: StrictConvexOn.convex_lt
File: Mathlib/Analysis/Convex/Function.lean

tactic: gcongr
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : StrictConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • f x + b • f y ≤ a • r + b • r
state_after: case h₁.hb
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : StrictConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ f x ≤ r

case h₂.hb
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : StrictConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ f y ≤ r

tactic: exact hx.2.le
state_before: case h₁.hb
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : StrictConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ f x ≤ r
state_after: no goals

tactic: exact hy.2.le
state_before: case h₂.hb
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : StrictConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x < r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x < r}
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ f y ≤ r
state_after: no goals
Theorem: WithTop.map₂_top_right
File: Mathlib/Order/WithBot.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
f : α → β → γ
a : WithTop α
⊢ map₂ f a ⊤ = ⊤
state_after: no goals
Theorem: OneOneReducible.of_equiv_symm
File: Mathlib/Computability/Reduce.lean

tactic: convert OneOneReducible.of_equiv _ h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
⊢ q ≤₁ (q ∘ ⇑e)
state_after: case h.e'_5
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
⊢ q = (q ∘ ⇑e) ∘ ⇑e.symm

tactic: funext
state_before: case h.e'_5
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
⊢ q = (q ∘ ⇑e) ∘ ⇑e.symm
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
x✝ : β
⊢ q x✝ = ((q ∘ ⇑e) ∘ ⇑e.symm) x✝

tactic: simp
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
x✝ : β
⊢ q x✝ = ((q ∘ ⇑e) ∘ ⇑e.symm) x✝
state_after: no goals
Theorem: Submodule.bot_ext
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: rcases x with ⟨x, xm⟩
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x y : ↥⊥
⊢ x = y
state_after: case mk
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
y : ↥⊥
x : M
xm : x ∈ ⊥
⊢ ⟨x, xm⟩ = y

tactic: rcases y with ⟨y, ym⟩
state_before: case mk
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
y : ↥⊥
x : M
xm : x ∈ ⊥
⊢ ⟨x, xm⟩ = y
state_after: case mk.mk
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x : M
xm : x ∈ ⊥
y : M
ym : y ∈ ⊥
⊢ ⟨x, xm⟩ = ⟨y, ym⟩

tactic: congr
state_before: case mk.mk
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x : M
xm : x ∈ ⊥
y : M
ym : y ∈ ⊥
⊢ ⟨x, xm⟩ = ⟨y, ym⟩
state_after: case mk.mk.e_val
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x : M
xm : x ∈ ⊥
y : M
ym : y ∈ ⊥
⊢ x = y

tactic: rw [(Submodule.eq_bot_iff _).mp rfl x xm]
state_before: case mk.mk.e_val
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x : M
xm : x ∈ ⊥
y : M
ym : y ∈ ⊥
⊢ x = y
state_after: case mk.mk.e_val
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x : M
xm : x ∈ ⊥
y : M
ym : y ∈ ⊥
⊢ 0 = y

tactic: rw [(Submodule.eq_bot_iff _).mp rfl y ym]
state_before: case mk.mk.e_val
R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
x : M
xm : x ∈ ⊥
y : M
ym : y ∈ ⊥
⊢ 0 = y
state_after: no goals
Theorem: Real.rpow_eq_zero_iff_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [rpow_def_of_nonneg hx]
state_before: x y z : ℝ
hx : 0 ≤ x
⊢ x ^ y = 0 ↔ x = 0 ∧ y ≠ 0
state_after: x y z : ℝ
hx : 0 ≤ x
⊢ (if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0

tactic: split_ifs <;> simp [*, exp_ne_zero]
state_before: x y z : ℝ
hx : 0 ≤ x
⊢ (if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0
state_after: no goals
Theorem: PMF.support_normalize
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [hf, mem_support_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0∞
hf0 : tsum f ≠ 0
hf : tsum f ≠ ⊤
a : α
⊢ a ∈ (normalize f hf0 hf).support ↔ a ∈ Function.support f
state_after: no goals
Theorem: jacobiSym.mul_right'
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: rw [jacobiSym, ((perm_factors_mul hb₁ hb₂).pmap _).prod_eq, List.pmap_append, List.prod_append]
state_before: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ J(a | b₁ * b₂) = J(a | b₁) * J(a | b₂)
state_after: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ (List.pmap (fun p pp => legendreSym p a) b₁.factors ⋯).prod *
      (List.pmap (fun p pp => legendreSym p a) b₂.factors ⋯).prod =
    J(a | b₁) * J(a | b₂)

case h
a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ ∀ a ∈ b₁.factors ++ b₂.factors, Nat.Prime a

case h
a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ ∀ a ∈ b₁.factors ++ b₂.factors, Nat.Prime a

tactic: case h => exact fun p hp => (List.mem_append.mp hp).elim prime_of_mem_factors prime_of_mem_factors
state_before: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ (List.pmap (fun p pp => legendreSym p a) b₁.factors ⋯).prod *
      (List.pmap (fun p pp => legendreSym p a) b₂.factors ⋯).prod =
    J(a | b₁) * J(a | b₂)

case h
a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ ∀ a ∈ b₁.factors ++ b₂.factors, Nat.Prime a

case h
a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ ∀ a ∈ b₁.factors ++ b₂.factors, Nat.Prime a
state_after: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ (List.pmap (fun p pp => legendreSym p a) b₁.factors ⋯).prod *
      (List.pmap (fun p pp => legendreSym p a) b₂.factors ⋯).prod =
    J(a | b₁) * J(a | b₂)

tactic: case _ => rfl
state_before: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ (List.pmap (fun p pp => legendreSym p a) b₁.factors ⋯).prod *
      (List.pmap (fun p pp => legendreSym p a) b₂.factors ⋯).prod =
    J(a | b₁) * J(a | b₂)
state_after: no goals

tactic: exact fun p hp => (List.mem_append.mp hp).elim prime_of_mem_factors prime_of_mem_factors
state_before: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ ∀ a ∈ b₁.factors ++ b₂.factors, Nat.Prime a
state_after: no goals

tactic: rfl
state_before: a : ℤ
b₁ b₂ : ℕ
hb₁ : b₁ ≠ 0
hb₂ : b₂ ≠ 0
⊢ (List.pmap (fun p pp => legendreSym p a) b₁.factors ⋯).prod *
      (List.pmap (fun p pp => legendreSym p a) b₂.factors ⋯).prod =
    J(a | b₁) * J(a | b₂)
state_after: no goals