tasksource/leandojo huggingface dataset:
Theorem: AffineSubspace.direction_eq_top_iff_of_nonempty
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: constructor
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
h : Set.Nonempty ↑s
⊢ direction s = ⊤ ↔ s = ⊤

tactic: intro hd
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
h : Set.Nonempty ↑s
⊢ direction s = ⊤ → s = ⊤

tactic: rw [← direction_top k V P] at hd
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
h : Set.Nonempty ↑s
hd : direction s = ⊤
⊢ s = ⊤

tactic: refine' ext_of_direction_eq hd _
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
h : Set.Nonempty ↑s
hd : direction s = direction ⊤
⊢ s = ⊤

tactic: simp [h]
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
h : Set.Nonempty ↑s
hd : direction s = direction ⊤
⊢ Set.Nonempty (↑s ∩ ↑⊤)

tactic: rintro rfl
state_before: case mpr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : AffineSubspace k P
h : Set.Nonempty ↑s
⊢ s = ⊤ → direction s = ⊤

tactic: simp
state_before: case mpr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
h : Set.Nonempty ↑⊤
⊢ direction ⊤ = ⊤
Theorem: toIcoMod_inj
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp_rw [toIcoMod_eq_toIcoMod, modEq_iff_eq_add_zsmul, sub_eq_iff_eq_add']
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c✝ : α
n : ℤ
c : α
⊢ toIcoMod hp c a = toIcoMod hp c b ↔ a ≡ b [PMOD p]
Theorem: Nat.add_factorial_le_factorial_add
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: cases' n1 with h
state_before: m n✝ i n : ℕ
n1 : 1 ≤ n
⊢ i + n ! ≤ (i + n)!

tactic: exact add_factorial_succ_le_factorial_add_succ i h
state_before: case step
m n i h : ℕ
a✝ : Nat.le 1 h
⊢ i + (succ h)! ≤ (i + succ h)!

tactic: exact self_le_factorial _
state_before: case refl
m n i : ℕ
⊢ i + 1! ≤ (i + 1)!
Theorem: QuaternionAlgebra.Basis.lift_add
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: simp [lift, add_smul]
state_before: R : Type u_1
A : Type u_2
B : Type ?u.73937
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
x y : ℍ[R,c₁,c₂]
⊢ lift q (x + y) = lift q x + lift q y

tactic: abel
state_before: R : Type u_1
A : Type u_2
B : Type ?u.73937
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
x y : ℍ[R,c₁,c₂]
⊢ ↑(algebraMap R A) x.re + ↑(algebraMap R A) y.re + (x.imI • q.i + y.imI • q.i) + (x.imJ • q.j + y.imJ • q.j) +
      (x.imK • q.k + y.imK • q.k) =
    ↑(algebraMap R A) x.re + x.imI • q.i + x.imJ • q.j + x.imK • q.k +
      (↑(algebraMap R A) y.re + y.imI • q.i + y.imJ • q.j + y.imK • q.k)
Theorem: Nat.le_of_add_le_add_left
File: src/lean/Init/Data/Nat/Basic.lean

tactic: match le.dest h with
| ⟨d, hd⟩ =>
  apply @le.intro _ _ d
  rw [Nat.add_assoc] at hd
  apply Nat.add_left_cancel hd
state_before: a b c : Nat
h : a + b ≤ a + c
⊢ b ≤ c

tactic: apply @le.intro _ _ d
state_before: a b c : Nat
h : a + b ≤ a + c
d : Nat
hd : a + b + d = a + c
⊢ b ≤ c

tactic: rw [Nat.add_assoc] at hd
state_before: a b c : Nat
h : a + b ≤ a + c
d : Nat
hd : a + b + d = a + c
⊢ b + d = c

tactic: apply Nat.add_left_cancel hd
state_before: a b c : Nat
h : a + b ≤ a + c
d : Nat
hd : a + (b + d) = a + c
⊢ b + d = c
Theorem: MulHom.subsemigroupMap_surjective
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: rintro ⟨_, x, hx, rfl⟩
state_before: M : Type u_1
N : Type u_2
P : Type ?u.76825
σ : Type ?u.76828
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
f : M →ₙ* N
M' : Subsemigroup M
⊢ Function.Surjective ↑(subsemigroupMap f M')

tactic: exact ⟨⟨x, hx⟩, rfl⟩
state_before: case mk.intro.intro
M : Type u_1
N : Type u_2
P : Type ?u.76825
σ : Type ?u.76828
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
f : M →ₙ* N
M' : Subsemigroup M
x : M
hx : x ∈ ↑M'
⊢ ∃ a, ↑(subsemigroupMap f M') a = { val := ↑f x, property := (_ : ∃ a, a ∈ ↑M' ∧ ↑f a = ↑f x) }
Theorem: Finset.toDual_max'
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithTop.coe_eq_coe]
state_before: F : Type ?u.356766
α : Type u_1
β : Type ?u.356772
γ : Type ?u.356775
ι : Type ?u.356778
κ : Type ?u.356781
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
hs : Finset.Nonempty s
⊢ ↑toDual (max' s hs) = min' (image (↑toDual) s) (_ : Finset.Nonempty (image (↑toDual) s))

tactic: simp only [max'_eq_sup', id_eq, toDual_sup', Function.comp_apply, coe_inf', min'_eq_inf',
  inf_image]
state_before: F : Type ?u.356766
α : Type u_1
β : Type ?u.356772
γ : Type ?u.356775
ι : Type ?u.356778
κ : Type ?u.356781
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
hs : Finset.Nonempty s
⊢ ↑(↑toDual (max' s hs)) = ↑(min' (image (↑toDual) s) (_ : Finset.Nonempty (image (↑toDual) s)))

tactic: rfl
state_before: F : Type ?u.356766
α : Type u_1
β : Type ?u.356772
γ : Type ?u.356775
ι : Type ?u.356778
κ : Type ?u.356781
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
hs : Finset.Nonempty s
⊢ inf s (WithTop.some ∘ fun x => ↑toDual x) = inf s ((WithTop.some ∘ fun x => x) ∘ ↑toDual)
Theorem: Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [SignType.nonpos_iff] at h
state_before: θ : Angle
h : sign θ ≤ 0
⊢ -↑(abs (toReal θ)) = θ

tactic: rcases h with (h | h)
state_before: θ : Angle
h : sign θ = -1 ∨ sign θ = 0
⊢ -↑(abs (toReal θ)) = θ

tactic: rw [abs_of_neg (toReal_neg_iff_sign_neg.2 h), coe_neg, neg_neg, coe_toReal]
state_before: case inl
θ : Angle
h : sign θ = -1
⊢ -↑(abs (toReal θ)) = θ

tactic: rw [sign_eq_zero_iff] at h
state_before: case inr
θ : Angle
h : sign θ = 0
⊢ -↑(abs (toReal θ)) = θ

tactic: rcases h with (rfl | rfl) <;> simp [abs_of_pos Real.pi_pos]
state_before: case inr
θ : Angle
h : θ = 0 ∨ θ = ↑π
⊢ -↑(abs (toReal θ)) = θ
Theorem: WittVector.ghostComponent_teichmullerFun
File: Mathlib/RingTheory/WittVector/Teichmuller.lean

tactic: rw [ghostComponent_apply, aeval_wittPolynomial, Finset.sum_eq_single 0, pow_zero, one_mul,
  tsub_zero]
state_before: p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
⊢ ↑(ghostComponent n) (teichmullerFun p r) = r ^ p ^ n

tactic: rfl
state_before: p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
⊢ coeff (teichmullerFun p r) 0 ^ p ^ n = r ^ p ^ n

tactic: intro i hi h0
state_before: case h₀
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
⊢ ∀ (b : ℕ), b ∈ Finset.range (n + 1) → b ≠ 0 → ↑p ^ b * coeff (teichmullerFun p r) b ^ p ^ (n - b) = 0

tactic: convert mul_zero (M₀ := R) _
state_before: case h₀
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n i : ℕ
hi : i ∈ Finset.range (n + 1)
h0 : i ≠ 0
⊢ ↑p ^ i * coeff (teichmullerFun p r) i ^ p ^ (n - i) = 0

tactic: convert zero_pow (M := R) _
state_before: case h.e'_2.h.e'_6
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n i : ℕ
hi : i ∈ Finset.range (n + 1)
h0 : i ≠ 0
⊢ coeff (teichmullerFun p r) i ^ p ^ (n - i) = 0

tactic: cases i
state_before: case h.e'_2.h.e'_5
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n i : ℕ
hi : i ∈ Finset.range (n + 1)
h0 : i ≠ 0
⊢ coeff (teichmullerFun p r) i = 0

tactic: contradiction
state_before: case h.e'_2.h.e'_5.zero
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
hi : Nat.zero ∈ Finset.range (n + 1)
h0 : Nat.zero ≠ 0
⊢ coeff (teichmullerFun p r) Nat.zero = 0

tactic: rfl
state_before: case h.e'_2.h.e'_5.succ
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n n✝ : ℕ
hi : Nat.succ n✝ ∈ Finset.range (n + 1)
h0 : Nat.succ n✝ ≠ 0
⊢ coeff (teichmullerFun p r) (Nat.succ n✝) = 0

tactic: exact pow_pos hp.1.pos _
state_before: case h.e'_2.h.e'_6.convert_2
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n i : ℕ
hi : i ∈ Finset.range (n + 1)
h0 : i ≠ 0
⊢ 0 < p ^ (n - i)

tactic: rw [Finset.mem_range]
state_before: case h₁
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
⊢ ¬0 ∈ Finset.range (n + 1) → ↑p ^ 0 * coeff (teichmullerFun p r) 0 ^ p ^ (n - 0) = 0

tactic: intro h
state_before: case h₁
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
⊢ ¬0 < n + 1 → ↑p ^ 0 * coeff (teichmullerFun p r) 0 ^ p ^ (n - 0) = 0

tactic: exact (h (Nat.succ_pos n)).elim
state_before: case h₁
p : ℕ
R : Type u_1
S : Type ?u.10109
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
n : ℕ
h : ¬0 < n + 1
⊢ ↑p ^ 0 * coeff (teichmullerFun p r) 0 ^ p ^ (n - 0) = 0
Theorem: Padic.addValuation.apply
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp only [Padic.addValuation, AddValuation.of_apply, addValuationDef, if_neg hx]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
hx : x ≠ 0
⊢ ↑addValuation x = ↑(valuation x)
Theorem: Mathlib.Meta.NormNum.isFibAux_two_mul
File: Mathlib/Tactic/NormNum/NatFib.lean

tactic: rw [← hn, fib_two_mul, H.1, H.2, ← h1]
state_before: n a b n' a' b' : ℕ
H : IsFibAux n a b
hn : 2 * n = n'
h1 : a * (2 * b - a) = a'
h2 : a * a + b * b = b'
⊢ fib n' = a'

tactic: rw [← hn, fib_two_mul_add_one, H.1, H.2, pow_two, pow_two, add_comm, h2]
state_before: n a b n' a' b' : ℕ
H : IsFibAux n a b
hn : 2 * n = n'
h1 : a * (2 * b - a) = a'
h2 : a * a + b * b = b'
⊢ fib (n' + 1) = b'
Theorem: MeasureTheory.Measure.fst_univ
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [fst_apply MeasurableSet.univ, preimage_univ]
state_before: α : Type u_1
α' : Type ?u.5371212
β : Type u_2
β' : Type ?u.5371218
γ : Type ?u.5371221
E : Type ?u.5371224
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
ρ : Measure (α × β)
⊢ ↑↑(fst ρ) univ = ↑↑ρ univ
Theorem: TopCat.Presheaf.pushforwardEq_hom_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: dsimp [Functor.op]
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ (Functor.op (Opens.map f)).obj U ⟶ (Functor.op (Opens.map g)).obj U

tactic: apply Quiver.Hom.op
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ ((Opens.map f).obj U.unop).op ⟶ ((Opens.map g).obj U.unop).op

tactic: apply eqToHom
state_before: case f
C : Type u
inst✝ : Category C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ (Opens.map g).obj U.unop ⟶ (Opens.map f).obj U.unop

tactic: rw [h]
state_before: case f.p
C : Type u
inst✝ : Category C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ (Opens.map g).obj U.unop = (Opens.map f).obj U.unop

tactic: simp [pushforwardEq]
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
U : (Opens ↑Y)ᵒᵖ
⊢ (pushforwardEq h ℱ).hom.app U = ℱ.map (id (eqToHom (_ : (Opens.map g).obj U.unop = (Opens.map f).obj U.unop)).op)
Theorem: MeasureTheory.OuterMeasure.exists_measurable_superset_forall_eq_trim
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: choose t hst ht hμt using fun i => (μ i).exists_measurable_superset_eq_trim s
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), ↑(μ i) t = ↑(trim (μ i)) s

tactic: replace hst := subset_iInter  hst
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
t : ι → Set α
hst : ∀ (i : ι), s ⊆ t i
ht : ∀ (i : ι), MeasurableSet (t i)
hμt : ∀ (i : ι), ↑(μ i) (t i) = ↑(trim (μ i)) s
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), ↑(μ i) t = ↑(trim (μ i)) s

tactic: replace ht := MeasurableSet.iInter ht
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
t : ι → Set α
ht : ∀ (i : ι), MeasurableSet (t i)
hμt : ∀ (i : ι), ↑(μ i) (t i) = ↑(trim (μ i)) s
hst : s ⊆ ⋂ (i : ι), t i
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), ↑(μ i) t = ↑(trim (μ i)) s

tactic: refine' ⟨⋂ i, t i, hst, ht, fun i => le_antisymm _ _⟩
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
t : ι → Set α
hμt : ∀ (i : ι), ↑(μ i) (t i) = ↑(trim (μ i)) s
hst : s ⊆ ⋂ (i : ι), t i
ht : MeasurableSet (⋂ (b : ι), t b)
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), ↑(μ i) t = ↑(trim (μ i)) s

tactic: exacts [hμt i ▸ (μ i).mono (iInter_subset _ _), (mono' _ hst).trans_eq ((μ i).trim_eq ht)]
state_before: case refine'_1
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
t : ι → Set α
hμt : ∀ (i : ι), ↑(μ i) (t i) = ↑(trim (μ i)) s
hst : s ⊆ ⋂ (i : ι), t i
ht : MeasurableSet (⋂ (b : ι), t b)
i : ι
⊢ ↑(μ i) (⋂ (i : ι), t i) ≤ ↑(trim (μ i)) s

case refine'_2
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
t : ι → Set α
hμt : ∀ (i : ι), ↑(μ i) (t i) = ↑(trim (μ i)) s
hst : s ⊆ ⋂ (i : ι), t i
ht : MeasurableSet (⋂ (b : ι), t b)
i : ι
⊢ ↑(trim (μ i)) s ≤ ↑(μ i) (⋂ (i : ι), t i)
Theorem: IsExposed.isClosed
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: obtain rfl | hB := B.eq_empty_or_nonempty
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B✝ C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A B : Set E
hAB : IsExposed 𝕜 A B
hA : IsClosed A
⊢ IsClosed B

tactic: obtain ⟨l, a, rfl⟩ := hAB.eq_inter_halfspace' hB
state_before: case inr
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B✝ C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A B : Set E
hAB : IsExposed 𝕜 A B
hA : IsClosed A
hB : Set.Nonempty B
⊢ IsClosed B

tactic: exact hA.isClosed_le continuousOn_const l.continuous.continuousOn
state_before: case inr.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A✝ B C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A : Set E
hA : IsClosed A
l : E →L[𝕜] 𝕜
a : 𝕜
hAB : IsExposed 𝕜 A {x | x ∈ A ∧ a ≤ ↑l x}
hB : Set.Nonempty {x | x ∈ A ∧ a ≤ ↑l x}
⊢ IsClosed {x | x ∈ A ∧ a ≤ ↑l x}

tactic: simp
state_before: case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : TopologicalSpace E
inst✝¹ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A✝ B C : Set E
X : Finset E
x : E
inst✝ : OrderClosedTopology 𝕜
A : Set E
hA : IsClosed A
hAB : IsExposed 𝕜 A ∅
⊢ IsClosed ∅
Theorem: AdjoinRoot.quotEquivQuotMap_symm_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [AdjoinRoot.quotEquivQuotMap_symm_apply,
  AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I✝ : Ideal R
f✝ f g : R[X]
I : Ideal R
⊢ ↑(AlgEquiv.symm (quotEquivQuotMap f I))
      (↑(Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) g)) =
    ↑(Ideal.Quotient.mk (Ideal.map (of f) I)) (↑(mk f) g)
Theorem: closure_nonempty_iff
File: Mathlib/Topology/Basic.lean

tactic: simp only [nonempty_iff_ne_empty, Ne.def, closure_empty_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ Set.Nonempty (closure s) ↔ Set.Nonempty s
Theorem: List.Nodup.mem_diff_iff
File: Mathlib/Data/List/Nodup.lean

tactic: rw [hl₁.diff_eq_filter, mem_filter, decide_eq_true_iff]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
hl₁ : Nodup l₁
⊢ a ∈ List.diff l₁ l₂ ↔ a ∈ l₁ ∧ ¬a ∈ l₂
Theorem: HasStrictDerivAt.const_sub
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.neg.const_add c
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 : Filter 𝕜
c : F
hf : HasStrictDerivAt f f' x
⊢ HasStrictDerivAt (fun x => c - f x) (-f') x
Theorem: Multiset.Nodup.product
File: Mathlib/Data/Multiset/Nodup.lean

tactic: simp [List.Nodup.product d₁ d₂]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.9045
r : α → α → Prop
s t✝ : Multiset α
a : α
t : Multiset β
l₁ : List α
l₂ : List β
d₁ : Nodup (Quotient.mk (isSetoid α) l₁)
d₂ : Nodup (Quotient.mk (isSetoid β) l₂)
⊢ Nodup (Quotient.mk (isSetoid α) l₁ ×ˢ Quotient.mk (isSetoid β) l₂)
Theorem: Monotone.countable_not_continuousAt
File: Mathlib/Topology/Algebra/Order/LeftRightLim.lean

tactic: apply
  (hf.countable_not_continuousWithinAt_Ioi.union hf.countable_not_continuousWithinAt_Iio).mono
    _
state_before: α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : ConditionallyCompleteLinearOrder β
inst✝⁴ : TopologicalSpace β
inst✝³ : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : TopologicalSpace.SecondCountableTopology β
⊢ Set.Countable {x | ¬ContinuousAt f x}

tactic: refine' compl_subset_compl.1 _
state_before: α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : ConditionallyCompleteLinearOrder β
inst✝⁴ : TopologicalSpace β
inst✝³ : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : TopologicalSpace.SecondCountableTopology β
⊢ {x | ¬ContinuousAt f x} ⊆ {x | ¬ContinuousWithinAt f (Ioi x) x} ∪ {x | ¬ContinuousWithinAt f (Iio x) x}

tactic: simp only [compl_union]
state_before: α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : ConditionallyCompleteLinearOrder β
inst✝⁴ : TopologicalSpace β
inst✝³ : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : TopologicalSpace.SecondCountableTopology β
⊢ ({x | ¬ContinuousWithinAt f (Ioi x) x} ∪ {x | ¬ContinuousWithinAt f (Iio x) x})ᶜ ⊆ {x | ¬ContinuousAt f x}ᶜ

tactic: rintro x ⟨hx, h'x⟩
state_before: α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : ConditionallyCompleteLinearOrder β
inst✝⁴ : TopologicalSpace β
inst✝³ : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : TopologicalSpace.SecondCountableTopology β
⊢ {x | ¬ContinuousWithinAt f (Ioi x) x}ᶜ ∩ {x | ¬ContinuousWithinAt f (Iio x) x}ᶜ ⊆ {x | ¬ContinuousAt f x}ᶜ

tactic: simp only [mem_setOf_eq, Classical.not_not, mem_compl_iff] at hx h'x⊢
state_before: case intro
α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : ConditionallyCompleteLinearOrder β
inst✝⁴ : TopologicalSpace β
inst✝³ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : TopologicalSpace.SecondCountableTopology β
x : α
hx : x ∈ {x | ¬ContinuousWithinAt f (Ioi x) x}ᶜ
h'x : x ∈ {x | ¬ContinuousWithinAt f (Iio x) x}ᶜ
⊢ x ∈ {x | ¬ContinuousAt f x}ᶜ

tactic: exact continuousAt_iff_continuous_left'_right'.2 ⟨h'x, hx⟩
state_before: case intro
α : Type u_2
β : Type u_1
inst✝⁶ : LinearOrder α
inst✝⁵ : ConditionallyCompleteLinearOrder β
inst✝⁴ : TopologicalSpace β
inst✝³ : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : TopologicalSpace.SecondCountableTopology β
x : α
hx : ContinuousWithinAt f (Ioi x) x
h'x : ContinuousWithinAt f (Iio x) x
⊢ ContinuousAt f x
Theorem: sSup_atoms_eq_top
File: Mathlib/Order/Atoms.lean

tactic: refine' Eq.trans (congr rfl (Set.ext fun x => _)) (sSup_atoms_le_eq ⊤)
state_before: α : Type u_1
β : Type ?u.19944
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
⊢ sSup {a | IsAtom a} = ⊤

tactic: exact (and_iff_left le_top).symm
state_before: α : Type u_1
β : Type ?u.19944
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
x : α
⊢ x ∈ {a | IsAtom a} ↔ x ∈ {a | IsAtom a ∧ a ≤ ⊤}
Theorem: StateT.run_seqRight
File: src/lean/Init/Control/Lawful.lean

tactic: show (x >>= fun _ => y).run s = _
state_before: m : Type u_1 → Type u_2
σ α β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : StateT σ m α
y : StateT σ m β
s : σ
⊢ run (SeqRight.seqRight x fun x => y) s = do
    let p ← run x s
    run y p.snd

tactic: simp
state_before: m : Type u_1 → Type u_2
σ α β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : StateT σ m α
y : StateT σ m β
s : σ
⊢ run
      (do
        let _ ← x
        y)
      s =
    do
    let p ← run x s
    run y p.snd
Theorem: Nat.ne_of_odd_add
File: Mathlib/Data/Nat/Parity.lean

tactic: simp [hnot] at h
state_before: m n : ℕ
h : Odd (m + n)
hnot : m = n
⊢ False
Theorem: Nat.WithBot.add_one_le_of_lt
File: Mathlib/Data/Nat/WithBot.lean

tactic: cases n
state_before: n m : WithBot ℕ
h : n < m
⊢ n + 1 ≤ m

tactic: cases m
state_before: case some
m : WithBot ℕ
val✝ : ℕ
h : some val✝ < m
⊢ some val✝ + 1 ≤ m

tactic: exacts [(not_lt_bot h).elim, WithBot.some_le_some.2 (WithBot.some_lt_some.1 h)]
state_before: case some.none
val✝ : ℕ
h : some val✝ < none
⊢ some val✝ + 1 ≤ none

case some.some
val✝¹ val✝ : ℕ
h : some val✝¹ < some val✝
⊢ some val✝¹ + 1 ≤ some val✝

tactic: exact bot_le
state_before: case none
m : WithBot ℕ
h : none < m
⊢ none + 1 ≤ m
Theorem: ProbabilityTheory.cond_mul_eq_inter'
File: Mathlib/Probability/ConditionalProbability.lean

tactic: rw [cond_apply μ hms t, mul_comm, ← mul_assoc, ENNReal.mul_inv_cancel hcs hcs', one_mul]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t✝ : Set Ω
hms : MeasurableSet s
hcs : ↑↑μ s ≠ 0
hcs' : ↑↑μ s ≠ ⊤
t : Set Ω
⊢ ↑↑(μ[|s]) t * ↑↑μ s = ↑↑μ (s ∩ t)
Theorem: Polynomial.mul_div_mod_by_monic_cancel_left
File: Mathlib/Data/Polynomial/Div.lean

tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hmo : Monic q
⊢ q * p /ₘ q = p

tactic: refine' (div_modByMonic_unique _ 0 hmo ⟨by rw [zero_add], _⟩).1
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hmo : Monic q
✝ : Nontrivial R
⊢ q * p /ₘ q = p

tactic: rw [degree_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hmo : Monic q
✝ : Nontrivial R
⊢ degree 0 < degree q

tactic: exact Ne.bot_lt fun h => hmo.ne_zero (degree_eq_bot.1 h)
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hmo : Monic q
✝ : Nontrivial R
⊢ ⊥ < degree q

tactic: rw [zero_add]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hmo : Monic q
✝ : Nontrivial R
⊢ 0 + q * p = q * p