tasksource/leandojo huggingface dataset:
Theorem: Nat.zero_lxor'
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp only [Bool.xor_false_left, Nat.bitwise'_zero_left, eq_self_iff_true, Bool.cond_true, lxor']
state_before: n : ℕ
⊢ lxor' 0 n = n
Theorem: Module.isTorsionBySet_iff_torsionBySet_eq_top
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [← mem_torsionBySet_iff, h]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
h : torsionBySet R M s = ⊤
x : M
⊢ ∀ ⦃a : ↑s⦄, ↑a • x = 0

tactic: trivial
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
h : torsionBySet R M s = ⊤
x : M
⊢ x ∈ ⊤
Theorem: PFun.mem_toSubtype_iff
File: Mathlib/Data/PFun.lean

tactic: rw [toSubtype_apply, Part.mem_mk_iff, exists_subtype_mk_eq_iff, eq_comm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.52355
δ : Type ?u.52358
ε : Type ?u.52361
ι : Type ?u.52364
f✝ : α →. β
p : β → Prop
f : α → β
a : α
b : Subtype p
⊢ b ∈ toSubtype p f a ↔ ↑b = f a
Theorem: ENNReal.ofReal_toReal_eq_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← h]
state_before: α : Type ?u.25366
β : Type ?u.25369
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal (ENNReal.toReal a) = a
⊢ a ≠ ⊤

tactic: exact ofReal_ne_top
state_before: α : Type ?u.25366
β : Type ?u.25369
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ENNReal.ofReal (ENNReal.toReal a) = a
⊢ ENNReal.ofReal (ENNReal.toReal a) ≠ ⊤
Theorem: FiniteDimensional.finrank_pi_fintype
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: letI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M✝ : Type v
N : Type w
inst✝¹⁴ : Ring R
inst✝¹³ : StrongRankCondition R
inst✝¹² : AddCommGroup M✝
inst✝¹¹ : Module R M✝
inst✝¹⁰ : Module.Free R M✝
inst✝⁹ : Module.Finite R M✝
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
inst✝⁶ : Module.Free R N
inst✝⁵ : Module.Finite R N
ι : Type v
inst✝⁴ : Fintype ι
M : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (M i)
inst✝² : (i : ι) → Module R (M i)
inst✝¹ : ∀ (i : ι), Module.Free R (M i)
inst✝ : ∀ (i : ι), Module.Finite R (M i)
⊢ finrank R ((i : ι) → M i) = ∑ i : ι, finrank R (M i)

tactic: simp only [finrank, fun i => rank_eq_card_chooseBasisIndex R (M i), rank_pi, ← mk_sigma,
  mk_toNat_eq_card, card_sigma]
state_before: R : Type u
M✝ : Type v
N : Type w
inst✝¹⁴ : Ring R
inst✝¹³ : StrongRankCondition R
inst✝¹² : AddCommGroup M✝
inst✝¹¹ : Module R M✝
inst✝¹⁰ : Module.Free R M✝
inst✝⁹ : Module.Finite R M✝
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
inst✝⁶ : Module.Free R N
inst✝⁵ : Module.Finite R N
ι : Type v
inst✝⁴ : Fintype ι
M : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (M i)
inst✝² : (i : ι) → Module R (M i)
inst✝¹ : ∀ (i : ι), Module.Free R (M i)
inst✝ : ∀ (i : ι), Module.Finite R (M i)
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ finrank R ((i : ι) → M i) = ∑ i : ι, finrank R (M i)
Theorem: CategoryTheory.Injective.Exact.comp_desc
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

tactic: convert congr_arg Quiver.Hom.unop (Exact.lift_comp h.op g.op f.op hgf (congrArg Quiver.Hom.op w))
state_before: C : Type u₁
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
inst✝² : HasImages Cᵒᵖ
inst✝¹ : HasEqualizers Cᵒᵖ
J Q R S : C
inst✝ : Injective J
h : R ⟶ J
f : Q ⟶ R
g : R ⟶ S
hgf : Exact g.op f.op
w : f ≫ h = 0
⊢ g ≫ desc h f g hgf w = h
Theorem: Int.isCoprime_iff_gcd_eq_one
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: constructor
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ IsCoprime m n ↔ gcd m n = 1

tactic: rintro ⟨a, b, h⟩
state_before: case mp
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ IsCoprime m n → gcd m n = 1

tactic: have : 1 = m * a + n * b := by rwa [mul_comm m, mul_comm n, eq_comm]
state_before: case mp.intro.intro
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
⊢ gcd m n = 1

tactic: exact Nat.dvd_one.mp (Int.gcd_dvd_iff.mpr ⟨a, b, this⟩)
state_before: case mp.intro.intro
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
this : 1 = m * a + n * b
⊢ gcd m n = 1

tactic: rwa [mul_comm m, mul_comm n, eq_comm]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n a b : ℤ
h : a * m + b * n = 1
⊢ 1 = m * a + n * b

tactic: rw [← Int.ofNat_inj, IsCoprime, Int.gcd_eq_gcd_ab, mul_comm m, mul_comm n, Nat.cast_one]
state_before: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ gcd m n = 1 → IsCoprime m n

tactic: intro h
state_before: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
⊢ gcdA m n * m + gcdB m n * n = 1 → ∃ a b, a * m + b * n = 1

tactic: exact ⟨_, _, h⟩
state_before: case mpr
R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℤ
h : gcdA m n * m + gcdB m n * n = 1
⊢ ∃ a b, a * m + b * n = 1
Theorem: IsROrC.conj_mul
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [mul_comm, mul_conj]
state_before: K : Type u_1
E : Type ?u.5102758
inst✝ : IsROrC K
x : K
⊢ ↑(starRingEnd K) x * x = ↑(↑normSq x)
Theorem: Equiv.set_finite_iff
File: Mathlib/Data/Set/Finite.lean

tactic: simp_rw [← Set.finite_coe_iff, hst.finite_iff]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hst : ↑s ≃ ↑t
⊢ Set.Finite s ↔ Set.Finite t
Theorem: Nat.ceil_eq_zero
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← le_zero_iff, ceil_le, Nat.cast_zero]
state_before: F : Type ?u.52773
α : Type u_1
β : Type ?u.52779
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ ⌈a⌉₊ = 0 ↔ a ≤ 0
Theorem: ENNReal.finset_sum_iSup_nat
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: refine' Finset.induction_on s _ _
state_before: α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
⊢ ∑ a in s, iSup (f a) = ⨆ (n : ι), ∑ a in s, f a n

tactic: simp
state_before: case refine'_1
α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
⊢ ∑ a in ∅, iSup (f a) = ⨆ (n : ι), ∑ a in ∅, f a n

tactic: intro a s has ih
state_before: case refine'_2
α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    ¬a ∈ s →
      (∑ a in s, iSup (f a) = ⨆ (n : ι), ∑ a in s, f a n) →
        ∑ a in insert a s, iSup (f a) = ⨆ (n : ι), ∑ a in insert a s, f a n

tactic: simp only [Finset.sum_insert has]
state_before: case refine'_2
α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : ¬a ∈ s
ih : ∑ a in s, iSup (f a) = ⨆ (n : ι), ∑ a in s, f a n
⊢ ∑ a in insert a s, iSup (f a) = ⨆ (n : ι), ∑ a in insert a s, f a n

tactic: rw [ih, iSup_add_iSup_of_monotone (hf a)]
state_before: case refine'_2
α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : ¬a ∈ s
ih : ∑ a in s, iSup (f a) = ⨆ (n : ι), ∑ a in s, f a n
⊢ iSup (f a) + ∑ a in s, iSup (f a) = ⨆ (n : ι), f a n + ∑ a in s, f a n

tactic: intro i j h
state_before: case refine'_2
α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : ¬a ∈ s
ih : ∑ a in s, iSup (f a) = ⨆ (n : ι), ∑ a in s, f a n
⊢ Monotone fun n => ∑ a in s, f a n

tactic: exact Finset.sum_le_sum fun a _ => hf a h
state_before: case refine'_2
α✝ : Type ?u.147988
β : Type ?u.147991
γ : Type ?u.147994
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_1
ι : Type u_2
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : ¬a ∈ s
ih : ∑ a in s, iSup (f a) = ⨆ (n : ι), ∑ a in s, f a n
i j : ι
h : i ≤ j
⊢ (fun n => ∑ a in s, f a n) i ≤ (fun n => ∑ a in s, f a n) j
Theorem: Hyperreal.Infinitesimal.mul
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simpa only [mul_zero] using hx.mul hy
state_before: x y : ℝ*
hx : Infinitesimal x
hy : Infinitesimal y
⊢ Infinitesimal (x * y)
Theorem: Sym2.ball
File: Mathlib/Data/Sym/Sym2.lean

tactic: refine' ⟨fun h => ⟨h _ <| mem_mk''_left _ _, h _ <| mem_mk''_right _ _⟩, fun h c hc => _⟩
state_before: α : Type u_1
β : Type ?u.34632
γ : Type ?u.34635
p : α → Prop
a b : α
⊢ (∀ (c : α), c ∈ Quotient.mk (Rel.setoid α) (a, b) → p c) ↔ p a ∧ p b

tactic: obtain rfl | rfl := Sym2.mem_iff.1 hc
state_before: α : Type u_1
β : Type ?u.34632
γ : Type ?u.34635
p : α → Prop
a b : α
h : p a ∧ p b
c : α
hc : c ∈ Quotient.mk (Rel.setoid α) (a, b)
⊢ p c

tactic: exact h.1
state_before: case inl
α : Type u_1
β : Type ?u.34632
γ : Type ?u.34635
p : α → Prop
b c : α
h : p c ∧ p b
hc : c ∈ Quotient.mk (Rel.setoid α) (c, b)
⊢ p c

tactic: exact h.2
state_before: case inr
α : Type u_1
β : Type ?u.34632
γ : Type ?u.34635
p : α → Prop
a c : α
h : p a ∧ p c
hc : c ∈ Quotient.mk (Rel.setoid α) (a, c)
⊢ p c
Theorem: cpow_eq_nhds'
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: suffices : ∀ᶠ x : ℂ × ℂ in 𝓝 p, x.1 ≠ 0
state_before: α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
⊢ (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => Complex.exp (Complex.log x.fst * x.snd)

tactic: exact
  this.mono fun x hx => by
    dsimp only
    rw [cpow_def_of_ne_zero hx]
state_before: α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
this : ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.fst ≠ 0
⊢ (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => Complex.exp (Complex.log x.fst * x.snd)

case this
α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
⊢ ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.fst ≠ 0

tactic: refine' IsOpen.eventually_mem _ hp_fst
state_before: case this
α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
⊢ ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.fst ≠ 0

tactic: change IsOpen ({ x : ℂ × ℂ | x.1 = 0 }ᶜ)
state_before: case this
α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
⊢ IsOpen fun x => x.fst = 0 → False

tactic: rw [isOpen_compl_iff]
state_before: case this
α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
⊢ IsOpen ({x | x.fst = 0}ᶜ)

tactic: exact isClosed_eq continuous_fst continuous_const
state_before: case this
α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
⊢ IsClosed {x | x.fst = 0}

tactic: dsimp only
state_before: α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
this : ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.fst ≠ 0
x : ℂ × ℂ
hx : x.fst ≠ 0
⊢ (fun x => x.fst ^ x.snd) x = (fun x => Complex.exp (Complex.log x.fst * x.snd)) x

tactic: rw [cpow_def_of_ne_zero hx]
state_before: α : Type ?u.99046
p : ℂ × ℂ
hp_fst : p.fst ≠ 0
this : ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.fst ≠ 0
x : ℂ × ℂ
hx : x.fst ≠ 0
⊢ x.fst ^ x.snd = Complex.exp (Complex.log x.fst * x.snd)
Theorem: Real.sInf_nonneg
File: Mathlib/Data/Real/Basic.lean

tactic: rcases S.eq_empty_or_nonempty with (rfl | hS₂)
state_before: x y : ℝ
S : Set ℝ
hS : ∀ (x : ℝ), x ∈ S → 0 ≤ x
⊢ 0 ≤ sInf S

tactic: exacts [sInf_empty.ge, le_csInf hS₂ hS]
state_before: case inl
x y : ℝ
hS : ∀ (x : ℝ), x ∈ ∅ → 0 ≤ x
⊢ 0 ≤ sInf ∅

case inr
x y : ℝ
S : Set ℝ
hS : ∀ (x : ℝ), x ∈ S → 0 ≤ x
hS₂ : Set.Nonempty S
⊢ 0 ≤ sInf S
Theorem: newton_seq_dist_to_a
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [sub_eq_add_neg, add_assoc, newton_seq_gen, newton_seq_aux, ih_n]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
_h : 0 < 1
⊢ ‖newton_seq 1 - a‖ = ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: rw [newton_seq_dist_to_a (k + 1) (succ_pos _)]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
k : ℕ
_h : 0 < k + 2
⊢ ‖newton_seq (k + 2) - newton_seq (k + 1)‖ < ‖newton_seq (k + 1) - a‖

tactic: apply newton_seq_succ_dist_weak
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
k : ℕ
_h : 0 < k + 2
⊢ ‖newton_seq (k + 2) - newton_seq (k + 1)‖ < ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: assumption
state_before: case hnsol
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
k : ℕ
_h : 0 < k + 2
⊢ Polynomial.eval a F ≠ 0

tactic: rw [← sub_add_sub_cancel]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
k : ℕ
_h : 0 < k + 2
hlt : ‖newton_seq (k + 2) - newton_seq (k + 1)‖ < ‖newton_seq (k + 1) - a‖
hne' : ‖newton_seq (k + 2) - newton_seq (k + 1)‖ ≠ ‖newton_seq (k + 1) - a‖
⊢ ‖newton_seq (k + 2) - a‖ = ‖newton_seq (k + 2) - newton_seq (k + 1) + (newton_seq (k + 1) - a)‖
Theorem: QuaternionAlgebra.rank_eq_four
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [rank_eq_card_basis (basisOneIJK c₁ c₂), Fintype.card_fin]
state_before: S : Type ?u.258028
T : Type ?u.258031
R : Type u_1
inst✝¹ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
inst✝ : StrongRankCondition R
⊢ Module.rank R ℍ[R,c₁,c₂] = 4

tactic: norm_num
state_before: S : Type ?u.258028
T : Type ?u.258031
R : Type u_1
inst✝¹ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
inst✝ : StrongRankCondition R
⊢ ↑4 = 4
Theorem: boundedSpace_induced_iff
File: Mathlib/Topology/Bornology/Constructions.lean

tactic: rw [← @isBounded_univ _ (Bornology.induced f), isBounded_induced, image_univ]
state_before: α✝ : Type ?u.106997
β✝ : Type ?u.107000
ι : Type ?u.107003
π : ι → Type ?u.107008
inst✝⁴ : Fintype ι
inst✝³ : Bornology α✝
inst✝² : Bornology β✝
inst✝¹ : (i : ι) → Bornology (π i)
α : Type u_1
β : Type u_2
inst✝ : Bornology β
f : α → β
⊢ BoundedSpace α ↔ IsBounded (range f)
Theorem: Subfield.mem_map
File: Mathlib/FieldTheory/Subfield.lean

tactic: unfold map
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
s✝ t : Subfield K
f✝ f : K →+* L
s : Subfield K
y : L
⊢ y ∈ map f s ↔ ∃ x, x ∈ s ∧ ↑f x = y

tactic: simp only [mem_mk, Subring.mem_mk, Subring.mem_toSubsemiring, Subring.mem_map, mem_toSubring]
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
s✝ t : Subfield K
f✝ f : K →+* L
s : Subfield K
y : L
⊢ (y ∈
      let src := Subring.map f s.toSubring;
      {
        toSubring :=
          { toSubsemiring := src.toSubsemiring,
            neg_mem' :=
              (_ :
                ∀ {x : L},
                  x ∈ (Subring.map f s.toSubring).toSubsemiring.toSubmonoid.toSubsemigroup.carrier →
                    -x ∈ (Subring.map f s.toSubring).toSubsemiring.toSubmonoid.toSubsemigroup.carrier) },
        inv_mem' :=
          (_ :
            ∀ (x : L),
              x ∈
                  { toSubsemiring := (Subring.map f s.toSubring).toSubsemiring,
                            neg_mem' :=
                              (_ :
                                ∀ {x : L},
                                  x ∈ (Subring.map f s.toSubring).toSubsemiring.toSubmonoid.toSubsemigroup.carrier →
                                    -x ∈
                                      (Subring.map f
                                                s.toSubring).toSubsemiring.toSubmonoid.toSubsemigroup.carrier) }.toSubsemiring.toSubmonoid.toSubsemigroup.carrier →
                x⁻¹ ∈
                  { toSubsemiring := (Subring.map f s.toSubring).toSubsemiring,
                            neg_mem' :=
                              (_ :
                                ∀ {x : L},
                                  x ∈ (Subring.map f s.toSubring).toSubsemiring.toSubmonoid.toSubsemigroup.carrier →
                                    -x ∈
                                      (Subring.map f
                                                s.toSubring).toSubsemiring.toSubmonoid.toSubsemigroup.carrier) }.toSubsemiring.toSubmonoid.toSubsemigroup.carrier) }) ↔
    ∃ x, x ∈ s ∧ ↑f x = y
Theorem: mem_segment_add_sub
File: Mathlib/Analysis/Convex/Segment.lean

tactic: convert @midpoint_mem_segment 𝕜 _ _ _ _ _ _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.167100
G : Type ?u.167103
ι : Type ?u.167106
π : ι → Type ?u.167111
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ x ∈ [x + y-[𝕜]x - y]

tactic: rw [midpoint_add_sub]
state_before: case h.e'_4
𝕜 : Type u_1
E : Type u_2
F : Type ?u.167100
G : Type ?u.167103
ι : Type ?u.167106
π : ι → Type ?u.167111
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
x✝ y✝ : E
inst✝ : Invertible 2
x y : E
⊢ x = midpoint 𝕜 (x + y) (x - y)
Theorem: Finset.eq_prod_range_div'
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: conv_lhs => rw [Finset.eq_prod_range_div f]
state_before: ι : Type ?u.621749
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
M : Type u_1
inst✝ : CommGroup M
f : ℕ → M
n : ℕ
⊢ f n = ∏ i in range (n + 1), if i = 0 then f 0 else f i / f (i - 1)

tactic: simp [Finset.prod_range_succ', mul_comm]
state_before: ι : Type ?u.621749
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
M : Type u_1
inst✝ : CommGroup M
f : ℕ → M
n : ℕ
⊢ f 0 * ∏ i in range n, f (i + 1) / f i = ∏ i in range (n + 1), if i = 0 then f 0 else f i / f (i - 1)
Theorem: Ordnode.Sized.node4L
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases m <;> [exact (hl.node' hm).node' hr; exact (hl.node' hm.2.1).node' (hm.2.2.node' hr)]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
hl : Sized l
hm : Sized m
hr : Sized r
⊢ Sized (Ordnode.node4L l x m y r)
Theorem: Finset.le_sup'
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_le_coe, coe_sup']
state_before: F : Type ?u.248430
α : Type u_2
β : Type u_1
γ : Type ?u.248439
ι : Type ?u.248442
κ : Type ?u.248445
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
b : β
h : b ∈ s
⊢ f b ≤ sup' s (_ : ∃ x, x ∈ s) f

tactic: exact le_sup (f := fun c => WithBot.some (f c)) h
state_before: F : Type ?u.248430
α : Type u_2
β : Type u_1
γ : Type ?u.248439
ι : Type ?u.248442
κ : Type ?u.248445
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
b : β
h : b ∈ s
⊢ ↑(f b) ≤ sup s (WithBot.some ∘ f)
Theorem: dist_mul_self_left
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_comm, dist_mul_self_right]
state_before: 𝓕 : Type ?u.57650
𝕜 : Type ?u.57653
α : Type ?u.57656
ι : Type ?u.57659
κ : Type ?u.57662
E : Type u_1
F : Type ?u.57668
G : Type ?u.57671
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist (a * b) b = ‖a‖
Theorem: MeasureTheory.AEDisjoint.iUnion_right_iff
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

tactic: simp only [AEDisjoint, inter_iUnion, measure_iUnion_null_iff]
state_before: ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s t✝ u v : Set α
inst✝ : Countable ι
t : ι → Set α
⊢ AEDisjoint μ s (⋃ (i : ι), t i) ↔ ∀ (i : ι), AEDisjoint μ s (t i)
Theorem: IsBoundedLinearMap.id
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: simp [le_refl]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.23732
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.23822
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
⊢ ∀ (x : E), ‖↑LinearMap.id x‖ ≤ 1 * ‖x‖
Theorem: AlgebraicGeometry.StructureSheaf.const_mul_cancel'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [mul_comm, const_mul_cancel]
state_before: R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₁ ∈ Ideal.primeCompl x.asIdeal
hu₂ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₂ ∈ Ideal.primeCompl x.asIdeal
⊢ const R g₁ g₂ U hu₂ * const R f g₁ U hu₁ = const R f g₂ U hu₂
Theorem: Behrend.box_zero
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: simp [box]
state_before: α : Type ?u.1778
β : Type ?u.1781
n d k N : ℕ
x : Fin n → ℕ
⊢ box (n + 1) 0 = ∅
Theorem: ZMod.val_nat_cast
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n a : ℕ
⊢ val ↑a = a % n

tactic: rw [← Fin.ofNat_eq_val]
state_before: case succ
a n✝ : ℕ
⊢ val ↑a = a % Nat.succ n✝

tactic: rfl
state_before: case succ
a n✝ : ℕ
⊢ val (Fin.ofNat'' a) = a % Nat.succ n✝

tactic: rw [Nat.mod_zero]
state_before: case zero
a : ℕ
⊢ val ↑a = a % Nat.zero

tactic: exact Int.natAbs_ofNat a
state_before: case zero
a : ℕ
⊢ val ↑a = a
Theorem: tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm
File: Mathlib/Analysis/Normed/Field/InfiniteSum.lean

tactic: simp_rw [← sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
state_before: R : Type u_1
ι : Type ?u.12044
ι' : Type ?u.12047
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ ((∑' (n : ℕ), f n) * ∑' (n : ℕ), g n) = ∑' (n : ℕ), ∑ k in range (n + 1), f k * g (n - k)

tactic: exact tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm hf hg
state_before: R : Type u_1
ι : Type ?u.12044
ι' : Type ?u.12047
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ ((∑' (n : ℕ), f n) * ∑' (n : ℕ), g n) = ∑' (n : ℕ), ∑ ij in antidiagonal n, f ij.fst * g ij.snd
Theorem: LowerSet.disjoint_prod
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [disjoint_iff, prod_inf_prod, prod_eq_bot]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.189730
ι : Sort ?u.189733
κ : ι → Sort ?u.189738
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂
Theorem: Polynomial.nodup_of_separable_prod
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [Multiset.nodup_iff_ne_cons_cons]
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
s : Multiset R
hs : Separable (Multiset.prod (Multiset.map (fun a => X - ↑C a) s))
⊢ Multiset.Nodup s

tactic: rintro a t rfl
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
s : Multiset R
hs : Separable (Multiset.prod (Multiset.map (fun a => X - ↑C a) s))
⊢ ∀ (a : R) (t : Multiset R), s ≠ a ::ₘ a ::ₘ t

tactic: refine' not_isUnit_X_sub_C a (isUnit_of_self_mul_dvd_separable hs _)
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
a : R
t : Multiset R
hs : Separable (Multiset.prod (Multiset.map (fun a => X - ↑C a) (a ::ₘ a ::ₘ t)))
⊢ False

tactic: simpa only [Multiset.map_cons, Multiset.prod_cons] using mul_dvd_mul_left _ (dvd_mul_right _ _)
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
a : R
t : Multiset R
hs : Separable (Multiset.prod (Multiset.map (fun a => X - ↑C a) (a ::ₘ a ::ₘ t)))
⊢ (X - ↑C a) * (X - ↑C a) ∣ Multiset.prod (Multiset.map (fun a => X - ↑C a) (a ::ₘ a ::ₘ t))