tasksource/leandojo huggingface dataset:
Theorem: Odd.sub_even
File: Mathlib/Algebra/Parity.lean

tactic: rw [sub_eq_add_neg]
state_before: F : Type ?u.104075
α : Type u_1
β : Type ?u.104081
R : Type ?u.104084
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Even b
⊢ Odd (a - b)

tactic: exact ha.add_even hb.neg
state_before: F : Type ?u.104075
α : Type u_1
β : Type ?u.104081
R : Type ?u.104084
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Even b
⊢ Odd (a + -b)
Theorem: MvPowerSeries.coeff_trunc
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp [trunc, coeff_truncFun]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n m : σ →₀ ℕ
φ : MvPowerSeries σ R
⊢ MvPolynomial.coeff m (↑(trunc R n) φ) = if m < n then ↑(coeff R m) φ else 0
Theorem: SimpleGraph.Walk.edges_concat
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [edges]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
h : Adj G v w
⊢ edges (concat p h) = List.concat (edges p) (Quotient.mk (Sym2.Rel.setoid V) (v, w))
Theorem: iteratedFDeriv_add_apply
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp_rw [← contDiffOn_univ, ← iteratedFDerivWithin_univ] at hf hg ⊢
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1770553
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f g : E → F
hf : ContDiff 𝕜 (↑i) f
hg : ContDiff 𝕜 (↑i) g
⊢ iteratedFDeriv 𝕜 i (f + g) x = iteratedFDeriv 𝕜 i f x + iteratedFDeriv 𝕜 i g x

tactic: exact iteratedFDerivWithin_add_apply hf hg uniqueDiffOn_univ (Set.mem_univ _)
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1770553
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i✝ i : ℕ
f g : E → F
hf : ContDiffOn 𝕜 (↑i) f univ
hg : ContDiffOn 𝕜 (↑i) g univ
⊢ iteratedFDerivWithin 𝕜 i (f + g) univ x = iteratedFDerivWithin 𝕜 i f univ x + iteratedFDerivWithin 𝕜 i g univ x
Theorem: Action.rightUnitor_hom_hom
File: Mathlib/RepresentationTheory/Action.lean

tactic: dsimp [Monoidal.transport_rightUnitor]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ (ρ_ X).hom.hom = (ρ_ X.V).hom

tactic: simp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 X.V ⊗ 𝟙 (𝟙_ V)) ≫ (ρ_ X.V).hom) ≫ 𝟙 X.V = (ρ_ X.V).hom
Theorem: Rat.cast_fract
File: Mathlib/Data/Rat/Floor.lean

tactic: simp only [fract, cast_sub, cast_coe_int, floor_cast]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : ℚ
⊢ ↑(fract x) = fract ↑x
Theorem: Nat.one_bits
File: Mathlib/Data/Nat/Bits.lean

tactic: convert bit1_bits 0
state_before: n : ℕ
⊢ bits 1 = [true]
Theorem: GromovHausdorff.candidates_nonneg
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

tactic: have : 0 ≤ 2 * f (x, y) :=
  calc
    0 = f (x, x) := (candidates_refl fA).symm
    _ ≤ f (x, y) + f (y, x) := (candidates_triangle fA)
    _ = f (x, y) + f (x, y) := by rw [candidates_symm fA]
    _ = 2 * f (x, y) := by ring
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
fA : f ∈ candidates X Y
⊢ 0 ≤ f (x, y)

tactic: linarith
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
fA : f ∈ candidates X Y
this : 0 ≤ 2 * f (x, y)
⊢ 0 ≤ f (x, y)

tactic: rw [candidates_symm fA]
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
fA : f ∈ candidates X Y
⊢ f (x, y) + f (y, x) = f (x, y) + f (x, y)

tactic: ring
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
fA : f ∈ candidates X Y
⊢ f (x, y) + f (x, y) = 2 * f (x, y)
Theorem: CategoryTheory.CommSq.HasLift.iff_op
File: Mathlib/CategoryTheory/CommSq.lean

tactic: rw [iff, iff]
state_before: C : Type u_1
inst✝ : Category C
A B X Y : C
f : A ⟶ X
i : A ⟶ B
p : X ⟶ Y
g : B ⟶ Y
sq : CommSq f i p g
⊢ HasLift sq ↔ HasLift (_ : CommSq g.op p.op i.op f.op)

tactic: exact Nonempty.congr (LiftStruct.opEquiv sq).toFun (LiftStruct.opEquiv sq).invFun
state_before: C : Type u_1
inst✝ : Category C
A B X Y : C
f : A ⟶ X
i : A ⟶ B
p : X ⟶ Y
g : B ⟶ Y
sq : CommSq f i p g
⊢ Nonempty (LiftStruct sq) ↔ Nonempty (LiftStruct (_ : CommSq g.op p.op i.op f.op))
Theorem: Set.sep_of_ncard_eq
File: Mathlib/Data/Set/Ncard.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.70582
s t : Set α
a b x y : α
f : α → β
P : α → Prop
h : ncard {x | x ∈ s ∧ P x} = ncard s
ha : a ∈ s
hs : autoParam (Set.Finite s) _auto✝
⊢ {x | x ∈ s ∧ P x} ⊆ s
Theorem: Polynomial.degree_mul'
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: refine' mt _ h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
⊢ p ≠ 0

tactic: exact fun hp => by rw [hp, leadingCoeff_zero, zero_mul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
⊢ p = 0 → leadingCoeff p * leadingCoeff q = 0

tactic: rw [hp, leadingCoeff_zero, zero_mul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p = 0
⊢ leadingCoeff p * leadingCoeff q = 0

tactic: refine' mt _ h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
⊢ q ≠ 0

tactic: exact fun hq => by rw [hq, leadingCoeff_zero, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
⊢ q = 0 → leadingCoeff p * leadingCoeff q = 0

tactic: rw [hq, leadingCoeff_zero, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
hq : q = 0
⊢ leadingCoeff p * leadingCoeff q = 0

tactic: rw [degree_eq_natDegree hp, degree_eq_natDegree hq]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ degree p + degree q ≤ degree (p * q)

tactic: refine le_degree_of_ne_zero (n := natDegree p + natDegree q) ?_
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ ↑(natDegree p) + ↑(natDegree q) ≤ degree (p * q)

tactic: rwa [coeff_mul_degree_add_degree]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.656983
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ coeff (p * q) (natDegree p + natDegree q) ≠ 0
Theorem: Filter.iInter_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa using biInter_mem finite_univ
state_before: α : Type u
f g : Filter α
s✝ t : Set α
β : Type v
s : β → Set α
inst✝ : Finite β
⊢ (⋂ (i : β), s i) ∈ f ↔ ∀ (i : β), s i ∈ f
Theorem: Option.map_map₂_antidistrib_left
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_antidistrib]
state_before: α : Type u_4
β : Type u_5
γ : Type u_3
f : α → β → γ
a : Option α
b : Option β
c : Option γ
δ : Type u_1
β' : Type u_2
g : γ → δ
f' : β' → α → δ
g' : β → β'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g' b) a
Theorem: Set.Ico_union_Ici'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.82412
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
⊢ Ico a b ∪ Ici c = Ici (min a c)

tactic: simp_rw [mem_union, mem_Ico, mem_Ici, min_le_iff]
state_before: case h
α : Type u_1
β : Type ?u.82412
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ∈ Ico a b ∪ Ici c ↔ x ∈ Ici (min a c)

tactic: by_cases hc : c ≤ x
state_before: case h
α : Type u_1
β : Type ?u.82412
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ a ≤ x ∧ x < b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

tactic: simp only [hc, or_true]
state_before: case pos
α : Type u_1
β : Type ?u.82412
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : c ≤ x
⊢ a ≤ x ∧ x < b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

tactic: have hxb : x < b := (lt_of_not_ge hc).trans_le h₁
state_before: case neg
α : Type u_1
β : Type ?u.82412
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
⊢ a ≤ x ∧ x < b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x

tactic: simp only [hxb, and_true]
state_before: case neg
α : Type u_1
β : Type ?u.82412
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
hxb : x < b
⊢ a ≤ x ∧ x < b ∨ c ≤ x ↔ a ≤ x ∨ c ≤ x
Theorem: Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
ψ : ℝ
⊢ cos θ = Real.cos ψ ↔ θ = ↑ψ ∨ θ = -↑ψ

tactic: exact cos_eq_iff_coe_eq_or_eq_neg
state_before: case h
ψ x✝ : ℝ
⊢ cos ↑x✝ = Real.cos ψ ↔ ↑x✝ = ↑ψ ∨ ↑x✝ = -↑ψ
Theorem: IsROrC.ofReal_tsum
File: Mathlib/Analysis/Complex/Basic.lean

tactic: by_cases h : Summable f
state_before: α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → ℝ
⊢ ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a)

tactic: exact ContinuousLinearMap.map_tsum ofRealClm h
state_before: case pos
α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → ℝ
h : Summable f
⊢ ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a)

tactic: rw [tsum_eq_zero_of_not_summable h,
  tsum_eq_zero_of_not_summable ((summable_ofReal _).not.mpr h), ofReal_zero]
state_before: case neg
α : Type u_2
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → ℝ
h : ¬Summable f
⊢ ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a)
Theorem: Nat.modEq_three_digits_sum
File: Mathlib/Data/Nat/Digits.lean

tactic: norm_num
state_before: n✝ n : ℕ
⊢ 10 % 3 = 1
Theorem: Polynomial.natDegree_add_coeff_mul
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: simp only [coeff_natDegree, coeff_mul_degree_add_degree]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r f g : R[X]
⊢ coeff (f * g) (natDegree f + natDegree g) = coeff f (natDegree f) * coeff g (natDegree g)
Theorem: Pmf.pure_bindOnSupport
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: refine' Pmf.ext fun b => _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112939
p : Pmf α
f✝ : (a : α) → a ∈ support p → Pmf β
a : α
f : (a' : α) → a' ∈ support (pure a) → Pmf β
⊢ bindOnSupport (pure a) f = f a (_ : a ∈ support (pure a))

tactic: simp only [bindOnSupport_apply, pure_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112939
p : Pmf α
f✝ : (a : α) → a ∈ support p → Pmf β
a : α
f : (a' : α) → a' ∈ support (pure a) → Pmf β
b : β
⊢ ↑(bindOnSupport (pure a) f) b = ↑(f a (_ : a ∈ support (pure a))) b

tactic: refine' _root_.trans (tsum_congr fun a' => _) (tsum_ite_eq a _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112939
p : Pmf α
f✝ : (a : α) → a ∈ support p → Pmf β
a : α
f : (a' : α) → a' ∈ support (pure a) → Pmf β
b : β
⊢ (∑' (a_1 : α),
      (if a_1 = a then 1 else 0) *
        if h : (if a_1 = a then 1 else 0) = 0 then 0 else ↑(f a_1 (_ : ¬↑(pure a) a_1 = 0)) b) =
    ↑(f a (_ : a ∈ support (pure a))) b

tactic: by_cases h : a' = a <;> simp [h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112939
p : Pmf α
f✝ : (a : α) → a ∈ support p → Pmf β
a : α
f : (a' : α) → a' ∈ support (pure a) → Pmf β
b : β
a' : α
⊢ ((if a' = a then 1 else 0) * if h : (if a' = a then 1 else 0) = 0 then 0 else ↑(f a' (_ : ¬↑(pure a) a' = 0)) b) =
    if a' = a then ↑(f a (_ : a ∈ support (pure a))) b else 0
Theorem: CategoryTheory.Quotient.induction
File: Mathlib/CategoryTheory/Quotient.lean

tactic: rintro ⟨x⟩ ⟨y⟩ ⟨f⟩
state_before: C : Type u_1
inst✝ : Category C
r : HomRel C
P : {a b : Quotient r} → (a ⟶ b) → Prop
h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)
⊢ ∀ {a b : Quotient r} (f : a ⟶ b), P f

tactic: exact h f
state_before: case mk.mk.mk
C : Type u_1
inst✝ : Category C
r : HomRel C
P : {a b : Quotient r} → (a ⟶ b) → Prop
h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)
x y : C
f✝ : { as := x } ⟶ { as := y }
f : { as := x }.as ⟶ { as := y }.as
⊢ P (Quot.mk (CompClosure r) f)
Theorem: Nat.choose_le_add
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction' b with b_n b_ih
state_before: a b c : ℕ
⊢ choose a c ≤ choose (a + b) c

tactic: exact le_trans b_ih (choose_le_succ (a + b_n) c)
state_before: case succ
a c b_n : ℕ
b_ih : choose a c ≤ choose (a + b_n) c
⊢ choose a c ≤ choose (a + succ b_n) c

tactic: simp
state_before: case zero
a c : ℕ
⊢ choose a c ≤ choose (a + zero) c
Theorem: Ideal.eq_jacobson_iff_not_mem
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: constructor
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
⊢ jacobson I = I ↔ ∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M

tactic: intro h x hx
state_before: case mp
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
⊢ jacobson I = I → ∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M

tactic: erw [← h, mem_sInf] at hx
state_before: case mp
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : jacobson I = I
x : R
hx : ¬x ∈ I
⊢ ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M

tactic: push_neg  at hx
state_before: case mp
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : jacobson I = I
x : R
hx : ¬∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsMaximal J} → x ∈ I_1
⊢ ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M

tactic: exact hx
state_before: case mp
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : jacobson I = I
x : R
hx : Exists fun ⦃I_1⦄ => I_1 ∈ {J | I ≤ J ∧ IsMaximal J} ∧ ¬x ∈ I_1
⊢ ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M

tactic: refine fun h => le_antisymm (fun x hx => ?_) le_jacobson
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
⊢ (∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M) → jacobson I = I

tactic: contrapose hx
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : ∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M
x : R
hx : x ∈ jacobson I
⊢ x ∈ I

tactic: erw [mem_sInf]
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : ∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M
x : R
hx : ¬x ∈ I
⊢ ¬x ∈ jacobson I

tactic: push_neg
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : ∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M
x : R
hx : ¬x ∈ I
⊢ ¬∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsMaximal J} → x ∈ I_1

tactic: exact h x hx
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
h : ∀ (x : R), ¬x ∈ I → ∃ M, (I ≤ M ∧ IsMaximal M) ∧ ¬x ∈ M
x : R
hx : ¬x ∈ I
⊢ Exists fun ⦃I_1⦄ => I_1 ∈ {J | I ≤ J ∧ IsMaximal J} ∧ ¬x ∈ I_1
Theorem: List.mem_range
File: Std/Data/List/Lemmas.lean

tactic: simp only [range_eq_range', mem_range'_1, Nat.zero_le, true_and, Nat.zero_add]
state_before: m n : Nat
⊢ m ∈ range n ↔ m < n
Theorem: Primrec.beq
File: Mathlib/Computability/Primrec.lean

tactic: simp [le_antisymm_iff]
state_before: α : Type u_1
β : Type ?u.133754
γ : Type ?u.133757
δ : Type ?u.133760
σ : Type ?u.133763
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : DecidableEq α
a : ℕ × ℕ
⊢ (fun x x_1 => x ≤ x_1) a.fst a.snd ∧ (fun x x_1 => x ≤ x_1) a.snd a.fst ↔ (fun a b => a = b) a.fst a.snd
Theorem: Convex.strictMonoOn_of_deriv_pos
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: intro x hx y hy
state_before: E : Type ?u.412812
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.412908
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ (x : ℝ), x ∈ interior D → 0 < deriv f x
⊢ StrictMonoOn f D

tactic: have : DifferentiableOn ℝ f (interior D) := fun z hz =>
  (differentiableAt_of_deriv_ne_zero (hf' z hz).ne').differentiableWithinAt
state_before: E : Type ?u.412812
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.412908
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ (x : ℝ), x ∈ interior D → 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
⊢ x < y → f x < f y

tactic: simpa only [zero_mul, sub_pos] using
  hD.mul_sub_lt_image_sub_of_lt_deriv hf this hf' x hx y hy
state_before: E : Type ?u.412812
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.412908
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ (x : ℝ), x ∈ interior D → 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
this : DifferentiableOn ℝ f (interior D)
⊢ x < y → f x < f y
Theorem: Finsupp.mem_toMultiset
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: rw [← Multiset.count_ne_zero, Finsupp.count_toMultiset, Finsupp.mem_support_iff]
state_before: α : Type u_1
β : Type ?u.57323
ι : Type ?u.57326
f : α →₀ ℕ
i : α
⊢ i ∈ ↑toMultiset f ↔ i ∈ f.support
Theorem: Mathlib.Tactic.Ring.mul_zero
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
⊢ a * 0 = 0
Theorem: BoxIntegral.Box.mk'_eq_coe
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: cases' I with lI uI hI
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ mk' l u = ↑I ↔ l = I.lower ∧ u = I.upper

tactic: rw [mk']
state_before: case mk
ι : Type u_1
J : Box ι
x y l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
⊢ mk' l u = ↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
    l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
      u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper

tactic: split_ifs with h
state_before: case mk
ι : Type u_1
J : Box ι
x y l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) =
      ↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
    l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
      u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper

tactic: simp [WithBot.coe_eq_coe]
state_before: case mk.inl
ι : Type u_1
J : Box ι
x y l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
h : ∀ (i : ι), l i < u i
⊢ ↑{ lower := l, upper := u, lower_lt_upper := h } = ↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
    l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
      u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper

tactic: suffices l = lI → u ≠ uI by simpa
state_before: case mk.inr
ι : Type u_1
J : Box ι
x y l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
h : ¬∀ (i : ι), l i < u i
⊢ ⊥ = ↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
    l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
      u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper

tactic: rintro rfl rfl
state_before: case mk.inr
ι : Type u_1
J : Box ι
x y l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
h : ¬∀ (i : ι), l i < u i
⊢ l = lI → u ≠ uI

tactic: exact h hI
state_before: case mk.inr
ι : Type u_1
J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
hI : ∀ (i : ι), l i < u i
⊢ False

tactic: simpa
state_before: ι : Type u_1
J : Box ι
x y l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
h : ¬∀ (i : ι), l i < u i
this : l = lI → u ≠ uI
⊢ ⊥ = ↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
    l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
      u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper
Theorem: Complex.exp_ne_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← exp_zero, ← add_neg_self x, exp_add, h]
state_before: x y : ℂ
h : exp x = 0
⊢ 0 = 1

tactic: simp
state_before: x y : ℂ
h : exp x = 0
⊢ x + -x = 0 * exp (-x)
Theorem: CircleDeg1Lift.iterate_pos_le_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [nsmul_eq_mul, add_right_iterate] using
  (f.commute_add_int m).iterate_pos_le_iff_map_le f.monotone (strictMono_id.add_const (m : ℝ)) hn
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
n : ℕ
hn : 0 < n
⊢ (↑f^[n]) x ≤ x + ↑n * ↑m ↔ ↑f x ≤ x + ↑m