tasksource/leandojo huggingface dataset:
Theorem: AffineBasis.ext_elem
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: cases nonempty_fintype ι
state_before: ι : Type u_1
ι' : Type ?u.127186
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Finite ι
q₁ q₂ : P
h : ∀ (i : ι), ↑(coord b i) q₁ = ↑(coord b i) q₂
⊢ q₁ = q₂

tactic: rw [← b.affineCombination_coord_eq_self q₁, ← b.affineCombination_coord_eq_self q₂]
state_before: case intro
ι : Type u_1
ι' : Type ?u.127186
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Finite ι
q₁ q₂ : P
h : ∀ (i : ι), ↑(coord b i) q₁ = ↑(coord b i) q₂
val✝ : Fintype ι
⊢ q₁ = q₂

tactic: simp only [h]
state_before: case intro
ι : Type u_1
ι' : Type ?u.127186
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Finite ι
q₁ q₂ : P
h : ∀ (i : ι), ↑(coord b i) q₁ = ↑(coord b i) q₂
val✝ : Fintype ι
⊢ (↑(Finset.affineCombination k Finset.univ ↑b) fun i => ↑(coord b i) q₁) =
    ↑(Finset.affineCombination k Finset.univ ↑b) fun i => ↑(coord b i) q₂
Theorem: Complex.exp_bound_sq
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: congr
state_before: z✝ y x✝ : ℝ
x z : ℂ
hz : ‖z‖ ≤ 1
⊢ ‖exp (x + z) - exp x - z * exp x‖ = ‖exp x * (exp z - 1 - z)‖

tactic: rw [exp_add]
state_before: case e_a
z✝ y x✝ : ℝ
x z : ℂ
hz : ‖z‖ ≤ 1
⊢ exp (x + z) - exp x - z * exp x = exp x * (exp z - 1 - z)

tactic: ring
state_before: case e_a
z✝ y x✝ : ℝ
x z : ℂ
hz : ‖z‖ ≤ 1
⊢ exp x * exp z - exp x - z * exp x = exp x * (exp z - 1 - z)
Theorem: Erased.out_inj
File: Mathlib/Data/Erased.lean

tactic: simpa using congr_arg mk h
state_before: α : Sort u_1
a b : Erased α
h : out a = out b
⊢ a = b
Theorem: Cubic.of_b_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_a_eq_zero ha, hb, C_0, MulZeroClass.zero_mul, zero_add]
state_before: R : Type u_1
S : Type ?u.419811
F : Type ?u.419814
K : Type ?u.419817
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
⊢ toPoly P = ↑C P.c * X + ↑C P.d
Theorem: Finsupp.disjoint_supported_supported_iff
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: refine' ⟨fun h => Set.disjoint_left.mpr fun x hx1 hx2 => _, disjoint_supported_supported⟩
state_before: α : Type u_2
M : Type u_1
N : Type ?u.115064
P : Type ?u.115067
R : Type u_3
S : Type ?u.115073
inst✝⁸ : Semiring R
inst✝⁷ : Semiring S
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : Nontrivial M
s t : Set α
⊢ Disjoint (supported M R s) (supported M R t) ↔ Disjoint s t

tactic: rcases exists_ne (0 : M) with ⟨y, hy⟩
state_before: α : Type u_2
M : Type u_1
N : Type ?u.115064
P : Type ?u.115067
R : Type u_3
S : Type ?u.115073
inst✝⁸ : Semiring R
inst✝⁷ : Semiring S
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : Nontrivial M
s t : Set α
h : Disjoint (supported M R s) (supported M R t)
x : α
hx1 : x ∈ s
hx2 : x ∈ t
⊢ False

tactic: have := h.le_bot ⟨single_mem_supported R y hx1, single_mem_supported R y hx2⟩
state_before: case intro
α : Type u_2
M : Type u_1
N : Type ?u.115064
P : Type ?u.115067
R : Type u_3
S : Type ?u.115073
inst✝⁸ : Semiring R
inst✝⁷ : Semiring S
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : Nontrivial M
s t : Set α
h : Disjoint (supported M R s) (supported M R t)
x : α
hx1 : x ∈ s
hx2 : x ∈ t
y : M
hy : y ≠ 0
⊢ False

tactic: rw [mem_bot, single_eq_zero] at this
state_before: case intro
α : Type u_2
M : Type u_1
N : Type ?u.115064
P : Type ?u.115067
R : Type u_3
S : Type ?u.115073
inst✝⁸ : Semiring R
inst✝⁷ : Semiring S
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : Nontrivial M
s t : Set α
h : Disjoint (supported M R s) (supported M R t)
x : α
hx1 : x ∈ s
hx2 : x ∈ t
y : M
hy : y ≠ 0
this : single x y ∈ ⊥
⊢ False

tactic: exact hy this
state_before: case intro
α : Type u_2
M : Type u_1
N : Type ?u.115064
P : Type ?u.115067
R : Type u_3
S : Type ?u.115073
inst✝⁸ : Semiring R
inst✝⁷ : Semiring S
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
inst✝² : AddCommMonoid P
inst✝¹ : Module R P
inst✝ : Nontrivial M
s t : Set α
h : Disjoint (supported M R s) (supported M R t)
x : α
hx1 : x ∈ s
hx2 : x ∈ t
y : M
hy : y ≠ 0
this : y = 0
⊢ False
Theorem: aeSeq.mk_eq_fun_of_mem_aeSeqSet
File: Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean

tactic: rw [aeSeqSet, ← compl_compl { x | ∀ i, f i x = (hf i).mk (f i) x }, Set.compl_subset_compl]
state_before: ι : Sort u_3
α : Type u_1
β : Type u_2
γ : Type ?u.154841
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i)
x : α
hx : x ∈ aeSeqSet hf p
i : ι
⊢ aeSeqSet hf p ⊆ {x | ∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x}

tactic: refine' Set.Subset.trans (Set.compl_subset_compl.mpr fun x h => _) (subset_toMeasurable _ _)
state_before: ι : Sort u_3
α : Type u_1
β : Type u_2
γ : Type ?u.154841
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i)
x : α
hx : x ∈ aeSeqSet hf p
i : ι
⊢ {x | ∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x}ᶜ ⊆
    toMeasurable μ ({x | (∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x) ∧ p x fun n => f n x}ᶜ)

tactic: exact h.1
state_before: ι : Sort u_3
α : Type u_1
β : Type u_2
γ : Type ?u.154841
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i)
x✝ : α
hx : x✝ ∈ aeSeqSet hf p
i : ι
x : α
h : x ∈ {x | (∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x) ∧ p x fun n => f n x}
⊢ x ∈ {x | ∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x}
Theorem: Real.le_rpow_iff_log_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← Real.log_le_log hx (Real.rpow_pos_of_pos hy z), Real.log_rpow hy]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
⊢ x ≤ y ^ z ↔ log x ≤ z * log y
Theorem: Finset.Nat.filter_fst_eq_antidiagonal
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: ext ⟨x, y⟩
state_before: n m : ℕ
⊢ filter (fun x => x.fst = m) (antidiagonal n) = if m ≤ n then {(m, n - m)} else ∅

tactic: simp only [mem_filter, Nat.mem_antidiagonal]
state_before: case a.mk
n m x y : ℕ
⊢ (x, y) ∈ filter (fun x => x.fst = m) (antidiagonal n) ↔ (x, y) ∈ if m ≤ n then {(m, n - m)} else ∅

tactic: split_ifs with h
state_before: case a.mk
n m x y : ℕ
⊢ x + y = n ∧ x = m ↔ (x, y) ∈ if m ≤ n then {(m, n - m)} else ∅

tactic: simp (config := { contextual := true }) [and_comm, eq_tsub_iff_add_eq_of_le h, add_comm]
state_before: case a.mk.inl
n m x y : ℕ
h : m ≤ n
⊢ x + y = n ∧ x = m ↔ (x, y) ∈ {(m, n - m)}

tactic: rw [not_le] at h
state_before: case a.mk.inr
n m x y : ℕ
h : ¬m ≤ n
⊢ x + y = n ∧ x = m ↔ (x, y) ∈ ∅

tactic: simp only [not_mem_empty, iff_false_iff, not_and, decide_eq_true_eq]
state_before: case a.mk.inr
n m x y : ℕ
h : n < m
⊢ x + y = n ∧ x = m ↔ (x, y) ∈ ∅

tactic: exact fun hn => ne_of_lt (lt_of_le_of_lt (le_self_add.trans hn.le) h)
state_before: case a.mk.inr
n m x y : ℕ
h : n < m
⊢ x + y = n → ¬x = m
Theorem: CategoryTheory.NatIso.isIso_inv_app
File: Mathlib/CategoryTheory/NatIso.lean

tactic: apply IsIso.eq_inv_of_hom_inv_id
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
inst✝ : IsIso α
X : C
⊢ (inv α).app X = inv (α.app X)

tactic: rw [← NatTrans.comp_app]
state_before: case hom_inv_id
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
inst✝ : IsIso α
X : C
⊢ α.app X ≫ (inv α).app X = 𝟙 (F.obj X)

tactic: simp
state_before: case hom_inv_id
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
X✝ Y : C
α : F ⟶ G
inst✝ : IsIso α
X : C
⊢ (α ≫ inv α).app X = 𝟙 (F.obj X)
Theorem: CharZero.of_module
File: Mathlib/Algebra/Module/Basic.lean

tactic: refine' ⟨fun m n h => @Nat.cast_injective M _ _ _ _ _⟩
state_before: α : Type ?u.280330
R : Type u_2
k : Type ?u.280336
S : Type ?u.280339
M✝ : Type ?u.280342
M₂ : Type ?u.280345
M₃ : Type ?u.280348
ι : Type ?u.280351
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M✝
inst✝³ : Module R M✝
M : Type u_1
inst✝² : AddCommMonoidWithOne M
inst✝¹ : CharZero M
inst✝ : Module R M
⊢ CharZero R

tactic: rw [← nsmul_one, ← nsmul_one, nsmul_eq_smul_cast R m (1 : M), nsmul_eq_smul_cast R n (1 : M), h]
state_before: α : Type ?u.280330
R : Type u_2
k : Type ?u.280336
S : Type ?u.280339
M✝ : Type ?u.280342
M₂ : Type ?u.280345
M₃ : Type ?u.280348
ι : Type ?u.280351
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M✝
inst✝³ : Module R M✝
M : Type u_1
inst✝² : AddCommMonoidWithOne M
inst✝¹ : CharZero M
inst✝ : Module R M
m n : ℕ
h : ↑m = ↑n
⊢ ↑m = ↑n
Theorem: TendstoLocallyUniformlyOn.tendsto_at
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: refine' ((tendstoLocallyUniformlyOn_iff_filter.mp hf) a ha).tendsto_at _
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hf : TendstoLocallyUniformlyOn F f p s
a : α
ha : a ∈ s
⊢ Tendsto (fun i => F i a) p (𝓝 (f a))

tactic: simpa only [Filter.principal_singleton] using pure_le_nhdsWithin ha
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
hf : TendstoLocallyUniformlyOn F f p s
a : α
ha : a ∈ s
⊢ 𝓟 {a} ≤ 𝓝[s] a
Theorem: List.eraseP_sublist
File: Std/Data/List/Lemmas.lean

tactic: match exists_or_eq_self_of_eraseP p l with
| .inl h => rw [h]; apply Sublist.refl
| .inr ⟨c, l₁, l₂, _, _, h₃, h₄⟩ => rw [h₄, h₃]; simp
state_before: α : Type u_1
p : α → Bool
l : List α
⊢ eraseP p l <+ l

tactic: rw [h]
state_before: α : Type u_1
p : α → Bool
l : List α
h : eraseP p l = l
⊢ eraseP p l <+ l

tactic: apply Sublist.refl
state_before: α : Type u_1
p : α → Bool
l : List α
h : eraseP p l = l
⊢ l <+ l

tactic: rw [h₄, h₃]
state_before: α : Type u_1
p : α → Bool
l : List α
c : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ eraseP p l <+ l

tactic: simp
state_before: α : Type u_1
p : α → Bool
l : List α
c : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ l₁ ++ l₂ <+ l₁ ++ c :: l₂
Theorem: LocalizedModule.lift'_smul
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: intro ⟨a, b⟩
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type ?u.503966
M'' : Type u_3
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
f : M →ₗ[R] M'
g✝ g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
r : R
m : LocalizedModule S M
⊢ ∀ (a : M × { x // x ∈ S }),
    r • lift' S g h (Quotient.mk (r.setoid S M) a) = lift' S g h (r • Quotient.mk (r.setoid S M) a)

tactic: erw [LocalizedModule.lift'_mk, LocalizedModule.smul'_mk, LocalizedModule.lift'_mk]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type ?u.503966
M'' : Type u_3
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
f : M →ₗ[R] M'
g✝ g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
r : R
m : LocalizedModule S M
a : M
b : { x // x ∈ S }
⊢ r • lift' S g h (Quotient.mk (r.setoid S M) (a, b)) = lift' S g h (r • Quotient.mk (r.setoid S M) (a, b))

tactic: erw [← map_smul, ← g.map_smul]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type ?u.503966
M'' : Type u_3
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
f : M →ₗ[R] M'
g✝ g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
r : R
m : LocalizedModule S M
a : M
b : { x // x ∈ S }
⊢ r • ↑↑(IsUnit.unit (_ : IsUnit (↑(algebraMap R (Module.End R M'')) ↑b)))⁻¹ (↑g a) =
    ↑↑(IsUnit.unit (_ : IsUnit (↑(algebraMap R (Module.End R M'')) ↑b)))⁻¹ (↑g (r • a))
Theorem: Nat.zero_of_testBit_eq_false
File: Mathlib/Data/Nat/Bitwise.lean

tactic: induction' n using Nat.binaryRec with b n hn
state_before: n : ℕ
h : ∀ (i : ℕ), testBit n i = false
⊢ n = 0

tactic: rfl
state_before: case z
n : ℕ
h✝ : ∀ (i : ℕ), testBit n i = false
h : ∀ (i : ℕ), testBit 0 i = false
⊢ 0 = 0

tactic: have : b = false := by simpa using h 0
state_before: case f
n✝ : ℕ
h✝ : ∀ (i : ℕ), testBit n✝ i = false
b : Bool
n : ℕ
hn : (∀ (i : ℕ), testBit n i = false) → n = 0
h : ∀ (i : ℕ), testBit (bit b n) i = false
⊢ bit b n = 0

tactic: rw [this, bit_false, bit0_val, hn fun i => by rw [← h (i + 1), testBit_succ], mul_zero]
state_before: case f
n✝ : ℕ
h✝ : ∀ (i : ℕ), testBit n✝ i = false
b : Bool
n : ℕ
hn : (∀ (i : ℕ), testBit n i = false) → n = 0
h : ∀ (i : ℕ), testBit (bit b n) i = false
this : b = false
⊢ bit b n = 0

tactic: simpa using h 0
state_before: n✝ : ℕ
h✝ : ∀ (i : ℕ), testBit n✝ i = false
b : Bool
n : ℕ
hn : (∀ (i : ℕ), testBit n i = false) → n = 0
h : ∀ (i : ℕ), testBit (bit b n) i = false
⊢ b = false

tactic: rw [← h (i + 1), testBit_succ]
state_before: n✝ : ℕ
h✝ : ∀ (i : ℕ), testBit n✝ i = false
b : Bool
n : ℕ
hn : (∀ (i : ℕ), testBit n i = false) → n = 0
h : ∀ (i : ℕ), testBit (bit b n) i = false
this : b = false
i : ℕ
⊢ testBit n i = false
Theorem: Equiv.arrowCongr_comp
File: Mathlib/Logic/Equiv/Defs.lean

tactic: ext
state_before: α : Sort u
β : Sort v
γ : Sort w
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ → β₁
g : β₁ → γ₁
⊢ ↑(arrowCongr ea ec) (g ∘ f) = ↑(arrowCongr eb ec) g ∘ ↑(arrowCongr ea eb) f

tactic: simp only [comp, arrowCongr_apply, eb.symm_apply_apply]
state_before: case h
α : Sort u
β : Sort v
γ : Sort w
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ → β₁
g : β₁ → γ₁
x✝ : α₂
⊢ ↑(arrowCongr ea ec) (g ∘ f) x✝ = (↑(arrowCongr eb ec) g ∘ ↑(arrowCongr ea eb) f) x✝
Theorem: List.zip_map_right
File: Mathlib/Data/List/Zip.lean

tactic: rw [← zip_map, map_id]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.23236
ε : Type ?u.23239
f : β → γ
l₁ : List α
l₂ : List β
⊢ zip l₁ (map f l₂) = map (Prod.map id f) (zip l₁ l₂)
Theorem: Set.preimage_const_mul_Ico_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Ico_of_neg a b h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x x_1 => x * x_1) c ⁻¹' Ico a b = Ioc (b / c) (a / c)
Theorem: Ordinal.add_lt_add_iff_left'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← not_le, ← not_le, add_le_add_iff_left]
state_before: α : Type ?u.55356
β : Type ?u.55359
γ : Type ?u.55362
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
⊢ a + b < a + c ↔ b < c
Theorem: MeasureTheory.Measure.measurable_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases h : HaveLebesgueDecomposition μ ν
state_before: α : Type u_1
β : Type ?u.32980
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ Measurable (rnDeriv μ ν)

tactic: exact (haveLebesgueDecomposition_spec μ ν).1
state_before: case pos
α : Type u_1
β : Type ?u.32980
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : HaveLebesgueDecomposition μ ν
⊢ Measurable (rnDeriv μ ν)

tactic: rw [rnDeriv, dif_neg h]
state_before: case neg
α : Type u_1
β : Type ?u.32980
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : ¬HaveLebesgueDecomposition μ ν
⊢ Measurable (rnDeriv μ ν)

tactic: exact measurable_zero
state_before: case neg
α : Type u_1
β : Type ?u.32980
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : ¬HaveLebesgueDecomposition μ ν
⊢ Measurable 0
Theorem: neg_mul_neg
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Mul α
inst✝ : HasDistribNeg α
a b : α
⊢ -a * -b = a * b
Theorem: Function.Injective.sOppSide_map_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: simp_rw [SOppSide, hf.wOppSide_map_iff, mem_map_iff_mem_of_injective hf]
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
hf : Function.Injective ↑f
⊢ SOppSide (map f s) (↑f x) (↑f y) ↔ SOppSide s x y
Theorem: IsLocalization.exists_integer_multiple
File: Mathlib/RingTheory/Localization/Integer.lean

tactic: simp_rw [Algebra.smul_def, mul_comm _ a]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.21895
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
a : S
⊢ ∃ b, IsInteger R (↑b • a)

tactic: apply exists_integer_multiple'
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.21895
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
a : S
⊢ ∃ b, IsInteger R (a * ↑(algebraMap R S) ↑b)
Theorem: SimpleGraph.singletonSubgraph_connected
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
⊢ Subgraph.Connected (SimpleGraph.singletonSubgraph G v)

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case preconnected
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
⊢ Preconnected (Subgraph.coe (SimpleGraph.singletonSubgraph G v))

tactic: simp only [singletonSubgraph_verts, Set.mem_singleton_iff] at ha hb
state_before: case preconnected.mk.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v a : V
ha : a ∈ (SimpleGraph.singletonSubgraph G v).verts
b : V
hb : b ∈ (SimpleGraph.singletonSubgraph G v).verts
⊢ Reachable (Subgraph.coe (SimpleGraph.singletonSubgraph G v)) { val := a, property := ha } { val := b, property := hb }

tactic: subst_vars
state_before: case preconnected.mk.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v a : V
ha✝ : a ∈ (SimpleGraph.singletonSubgraph G v).verts
b : V
hb✝ : b ∈ (SimpleGraph.singletonSubgraph G v).verts
ha : a = v
hb : b = v
⊢ Reachable (Subgraph.coe (SimpleGraph.singletonSubgraph G v)) { val := a, property := ha✝ }
    { val := b, property := hb✝ }

tactic: rfl
state_before: case preconnected.mk.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
b : V
ha hb : b = b
⊢ Reachable (Subgraph.coe (SimpleGraph.singletonSubgraph G b)) { val := b, property := (_ : b = b) }
    { val := b, property := (_ : b = b) }
Theorem: IsOpenMap.prod
File: Mathlib/Topology/Constructions.lean

tactic: rw [isOpenMap_iff_nhds_le]
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type u_2
ε : Type ?u.96477
ζ : Type ?u.96480
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β
g : γ → δ
hf : IsOpenMap f
hg : IsOpenMap g
⊢ IsOpenMap fun p => (f p.fst, g p.snd)

tactic: rintro ⟨a, b⟩
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type u_2
ε : Type ?u.96477
ζ : Type ?u.96480
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β
g : γ → δ
hf : IsOpenMap f
hg : IsOpenMap g
⊢ ∀ (a : α × γ), 𝓝 (f a.fst, g a.snd) ≤ map (fun p => (f p.fst, g p.snd)) (𝓝 a)

tactic: rw [nhds_prod_eq, nhds_prod_eq, ← Filter.prod_map_map_eq]
state_before: case mk
α : Type u
β : Type v
γ : Type u_1
δ : Type u_2
ε : Type ?u.96477
ζ : Type ?u.96480
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β
g : γ → δ
hf : IsOpenMap f
hg : IsOpenMap g
a : α
b : γ
⊢ 𝓝 (f (a, b).fst, g (a, b).snd) ≤ map (fun p => (f p.fst, g p.snd)) (𝓝 (a, b))

tactic: exact Filter.prod_mono (hf.nhds_le a) (hg.nhds_le b)
state_before: case mk
α : Type u
β : Type v
γ : Type u_1
δ : Type u_2
ε : Type ?u.96477
ζ : Type ?u.96480
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β
g : γ → δ
hf : IsOpenMap f
hg : IsOpenMap g
a : α
b : γ
⊢ 𝓝 (f (a, b).fst) ×ˢ 𝓝 (g (a, b).snd) ≤ map f (𝓝 a) ×ˢ map g (𝓝 b)
Theorem: List.reverse_replicate
File: Mathlib/Data/List/Basic.lean

tactic: rw [length_reverse, length_replicate]
state_before: ι : Type ?u.27597
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
a : α
⊢ length (reverse (replicate n a)) = n
Theorem: Finset.Iic_erase
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.117576
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderBot α
inst✝ : DecidableEq α
b : α
⊢ erase (Iic b) b = Iio b

tactic: simp_rw [Finset.mem_erase, mem_Iic, mem_Iio, lt_iff_le_and_ne, and_comm]
state_before: case a
ι : Type ?u.117576
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderBot α
inst✝ : DecidableEq α
b a✝ : α
⊢ a✝ ∈ erase (Iic b) b ↔ a✝ ∈ Iio b
Theorem: Submodule.fg_biSup
File: Mathlib/RingTheory/Finiteness.lean

tactic: simpa only [Finset.sup_eq_iSup] using fg_finset_sup s N h
state_before: R : Type u_2
M : Type u_3
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
ι : Type u_1
s : Finset ι
N : ι → Submodule R M
h : ∀ (i : ι), i ∈ s → FG (N i)
⊢ FG (⨆ (i : ι) (_ : i ∈ s), N i)
Theorem: Complex.ringHom_eq_ofReal_of_continuous
File: Mathlib/Analysis/Complex/Basic.lean

tactic: convert congr_arg AlgHom.toRingHom <| Subsingleton.elim (AlgHom.mk' f <| map_real_smul f h)
  (Algebra.ofId ℝ ℂ)
state_before: E : Type ?u.1071891
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ →+* ℂ
h : Continuous ↑f
⊢ f = ofReal
Theorem: Primrec.list_get?₁
File: Mathlib/Computability/Primrec.lean

tactic: cases n <;> simp
state_before: α : Type u_1
σ : Type ?u.50240
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
a : α
l : List α
n : ℕ
⊢ (Nat.casesOn n (Nat.succ (encode a)) fun n => encode (List.get? l (ofNat ℕ n))) =
    encode (List.get? (a :: l) (ofNat ℕ n))
Theorem: ProbabilityTheory.cond_isProbabilityMeasure
File: Mathlib/Probability/ConditionalProbability.lean

tactic: rw [cond, Measure.smul_apply, Measure.restrict_apply MeasurableSet.univ, Set.univ_inter]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hcs : ↑↑μ s ≠ 0
⊢ ↑↑(μ[|s]) Set.univ = 1

tactic: exact ENNReal.inv_mul_cancel hcs (measure_ne_top _ s)
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hcs : ↑↑μ s ≠ 0
⊢ (↑↑μ s)⁻¹ • ↑↑μ s = 1
Theorem: Int.dvd_of_dvd_mul_right_of_gcd_one
File: Mathlib/Data/Int/GCD.lean

tactic: rw [mul_comm] at habc
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a b = 1
⊢ a ∣ c

tactic: exact dvd_of_dvd_mul_left_of_gcd_one habc hab
state_before: a b c : ℤ
habc : a ∣ c * b
hab : gcd a b = 1
⊢ a ∣ c