tasksource/leandojo huggingface dataset:
Theorem: MulChar.pow_apply_coe
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: induction' n with n ih
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
n : ℕ
a : Rˣ
⊢ ↑(χ ^ n) ↑a = ↑χ ↑a ^ n

tactic: rw [pow_zero, pow_zero, one_apply_coe]
state_before: case zero
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a : Rˣ
⊢ ↑(χ ^ Nat.zero) ↑a = ↑χ ↑a ^ Nat.zero

tactic: rw [pow_succ, pow_succ, mul_apply, ih]
state_before: case succ
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a : Rˣ
n : ℕ
ih : ↑(χ ^ n) ↑a = ↑χ ↑a ^ n
⊢ ↑(χ ^ Nat.succ n) ↑a = ↑χ ↑a ^ Nat.succ n
Theorem: Hyperreal.infiniteNeg_of_tendsto_bot
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simp only [Set.compl_setOf, not_lt]
state_before: f : ℕ → ℝ
hf : Tendsto f atTop atBot
r : ℝ
hf' : ∀ (b : ℝ), ∃ i, ∀ (a : ℕ), i ≤ a → f a ≤ b
i : ℕ
hi : ∀ (a : ℕ), i ≤ a → f a ≤ r - 1
hi' : ∀ (a : ℕ), r - 1 < f a → a < i
⊢ {a | f a < r}ᶜ ⊆ {a | a ≤ i}

tactic: exact fun a har => le_of_lt (hi' a (lt_of_lt_of_le (sub_one_lt _) har))
state_before: f : ℕ → ℝ
hf : Tendsto f atTop atBot
r : ℝ
hf' : ∀ (b : ℝ), ∃ i, ∀ (a : ℕ), i ≤ a → f a ≤ b
i : ℕ
hi : ∀ (a : ℕ), i ≤ a → f a ≤ r - 1
hi' : ∀ (a : ℕ), r - 1 < f a → a < i
⊢ {a | r ≤ f a} ⊆ {a | a ≤ i}
Theorem: Partrec.sum_casesOn_left
File: Mathlib/Computability/Partrec.lean

tactic: cases f a <;> simp
state_before: α : Type u_4
β : Type u_1
γ : Type u_2
σ : Type u_3
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β ⊕ γ
g : α → β →. σ
h : α → γ → σ
hf : Computable f
hg : Partrec₂ g
hh : Computable₂ h
a : α
⊢ Sum.casesOn (Sum.casesOn (f a) (fun b => Sum.inr (a, b).snd) fun b => Sum.inl (a, b).snd) (fun b => Part.some (h a b))
      (g a) =
    Sum.casesOn (f a) (g a) fun c => Part.some (h a c)
Theorem: Filter.Germ.const_min
File: Mathlib/Order/Filter/FilterProduct.lean

tactic: rw [min_def, map₂_const]
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : LinearOrder β
x y : β
⊢ ↑(min x y) = min ↑x ↑y
Theorem: Nat.le_mul_self
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: simp
state_before: m n✝ k l n : ℕ
⊢ n + 1 ≤ (n + 1) * (n + 1)
Theorem: Nat.Prime.dvd_choose_add
File: Mathlib/Data/Nat/Choose/Dvd.lean

tactic: have h₁ : p ∣ (a + b)! := hp.dvd_factorial.2 h
state_before: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
⊢ p ∣ choose (a + b) a

tactic: rw [← add_choose_mul_factorial_mul_factorial, ← choose_symm_add, hp.dvd_mul, hp.dvd_mul,
  hp.dvd_factorial, hp.dvd_factorial] at h₁
state_before: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
h₁ : p ∣ (a + b)!
⊢ p ∣ choose (a + b) a

tactic: exact (h₁.resolve_right hbp.not_le).resolve_right hap.not_le
state_before: p a b k : ℕ
hp : Prime p
hap : a < p
hbp : b < p
h : p ≤ a + b
h₁ : (p ∣ choose (a + b) a ∨ p ≤ a) ∨ p ≤ b
⊢ p ∣ choose (a + b) a
Theorem: MvPolynomial.mem_restrictDegree
File: Mathlib/RingTheory/MvPolynomial/Basic.lean

tactic: rw [restrictDegree, Finsupp.mem_supported]
state_before: σ : Type u
R : Type v
inst✝ : CommRing R
p✝ m : ℕ
p : MvPolynomial σ R
n : ℕ
⊢ p ∈ restrictDegree σ R n ↔ ∀ (s : σ →₀ ℕ), s ∈ support p → ∀ (i : σ), ↑s i ≤ n

tactic: rfl
state_before: σ : Type u
R : Type v
inst✝ : CommRing R
p✝ m : ℕ
p : MvPolynomial σ R
n : ℕ
⊢ ↑p.support ⊆ {n_1 | ∀ (i : σ), ↑n_1 i ≤ n} ↔ ∀ (s : σ →₀ ℕ), s ∈ support p → ∀ (i : σ), ↑s i ≤ n
Theorem: List.reverse_prefix
File: Std/Data/List/Lemmas.lean

tactic: rw [← reverse_suffix]
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
⊢ reverse l₁ <+: reverse l₂ ↔ l₁ <:+ l₂

tactic: simp only [reverse_reverse]
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
⊢ reverse (reverse l₁) <:+ reverse (reverse l₂) ↔ l₁ <:+ l₂
Theorem: le_map_inv_iff
File: Mathlib/Order/Hom/Basic.lean

tactic: convert (@map_le_map_iff _ _ _ _ _ _ f a (EquivLike.inv f b)).symm
state_before: F : Type u_2
α : Type u_1
β : Type u_3
γ : Type ?u.29401
δ : Type ?u.29404
inst✝² : LE α
inst✝¹ : LE β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ a ≤ EquivLike.inv f b ↔ ↑f a ≤ b

tactic: exact (EquivLike.right_inv _ _).symm
state_before: case h.e'_2.h.e'_4
F : Type u_2
α : Type u_1
β : Type u_3
γ : Type ?u.29401
δ : Type ?u.29404
inst✝² : LE α
inst✝¹ : LE β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ b = ↑f (EquivLike.inv f b)
Theorem: Set.preimage_boolIndicator_eq_union
File: Mathlib/Data/Set/BoolIndicator.lean

tactic: ext x
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ boolIndicator s ⁻¹' t = (if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅

tactic: simp only [boolIndicator, mem_preimage]
state_before: case h
α : Type u_1
s : Set α
t : Set Bool
x : α
⊢ x ∈ boolIndicator s ⁻¹' t ↔ x ∈ (if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅

tactic: split_ifs <;> simp [*]
state_before: case h
α : Type u_1
s : Set α
t : Set Bool
x : α
⊢ (if x ∈ s then true else false) ∈ t ↔ x ∈ (if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅
Theorem: Ordnode.balance_sz_dual
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [size_dual, size_dual]
state_before: α : Type u_1
l r : Ordnode α
H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨ ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r'
⊢ (∃ l', Raised l' (size (dual r)) ∧ BalancedSz l' (size (dual l))) ∨
    ∃ r', Raised (size (dual l)) r' ∧ BalancedSz (size (dual r)) r'

tactic: exact
  H.symm.imp (Exists.imp fun _ => And.imp_right BalancedSz.symm)
    (Exists.imp fun _ => And.imp_right BalancedSz.symm)
state_before: α : Type u_1
l r : Ordnode α
H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨ ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r'
⊢ (∃ l', Raised l' (size r) ∧ BalancedSz l' (size l)) ∨ ∃ r', Raised (size l) r' ∧ BalancedSz (size r) r'
Theorem: MvPowerSeries.coeff_truncFun
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp [truncFun, MvPolynomial.coeff_sum]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n m : σ →₀ ℕ
φ : MvPowerSeries σ R
⊢ MvPolynomial.coeff m (truncFun n φ) = if m < n then ↑(coeff R m) φ else 0
Theorem: Wbtw.wSameSide₂₃
File: Mathlib/Analysis/Convex/Side.lean

tactic: rcases h with ⟨t, ⟨ht0, -⟩, rfl⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.198200
P : Type u_3
P' : Type ?u.198206
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 z : P
h : Wbtw R x y z
hx : x ∈ s
⊢ WSameSide s y z

tactic: exact wSameSide_lineMap_left z hx ht0
state_before: case intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.198200
P : Type u_3
P' : Type ?u.198206
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 z : P
hx : x ∈ s
t : R
ht0 : 0 ≤ t
⊢ WSameSide s (↑(lineMap x z) t) z
Theorem: MulAut.conjNormal_symm_apply
File: Mathlib/GroupTheory/GroupAction/ConjAct.lean

tactic: change _ * _⁻¹⁻¹ = _
state_before: α : Type ?u.89699
M : Type ?u.89702
G : Type u_1
G₀ : Type ?u.89708
R : Type ?u.89711
K : Type ?u.89714
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
g : G
h : { x // x ∈ H }
⊢ ↑(↑(MulEquiv.symm (↑MulAut.conjNormal g)) h) = g⁻¹ * ↑h * g

tactic: rw [inv_inv]
state_before: α : Type ?u.89699
M : Type ?u.89702
G : Type u_1
G₀ : Type ?u.89708
R : Type ?u.89711
K : Type ?u.89714
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
g : G
h : { x // x ∈ H }
⊢ ↑ofConjAct (↑(MulEquiv.toMonoidHom toConjAct) g)⁻¹ * ↑h * (↑(MulEquiv.toMonoidHom toConjAct) g)⁻¹⁻¹ = g⁻¹ * ↑h * g

tactic: rfl
state_before: α : Type ?u.89699
M : Type ?u.89702
G : Type u_1
G₀ : Type ?u.89708
R : Type ?u.89711
K : Type ?u.89714
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
g : G
h : { x // x ∈ H }
⊢ ↑ofConjAct (↑(MulEquiv.toMonoidHom toConjAct) g)⁻¹ * ↑h * ↑(MulEquiv.toMonoidHom toConjAct) g = g⁻¹ * ↑h * g
Theorem: PNat.Coprime.mul
File: Mathlib/Data/PNat/Prime.lean

tactic: repeat' rw [← coprime_coe]
state_before: k m n : ℕ+
⊢ Coprime m k → Coprime n k → Coprime (m * n) k

tactic: rw [mul_coe]
state_before: k m n : ℕ+
⊢ coprime ↑m ↑k → coprime ↑n ↑k → coprime ↑(m * n) ↑k

tactic: apply Nat.coprime.mul
state_before: k m n : ℕ+
⊢ coprime ↑m ↑k → coprime ↑n ↑k → coprime (↑m * ↑n) ↑k

tactic: rw [← coprime_coe]
state_before: k m n : ℕ+
⊢ coprime ↑m ↑k → coprime ↑n ↑k → coprime ↑(m * n) ↑k
Theorem: Polynomial.degree_sub_lt
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: unfold natDegree
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
hd : degree p = degree q
hp0 : p ≠ 0
hlc : leadingCoeff p = leadingCoeff q
hp : ↑(monomial (natDegree p)) (leadingCoeff p) + erase (natDegree p) p = p
hq : ↑(monomial (natDegree q)) (leadingCoeff q) + erase (natDegree q) q = q
⊢ natDegree p = natDegree q

tactic: rw [hd]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
hd : degree p = degree q
hp0 : p ≠ 0
hlc : leadingCoeff p = leadingCoeff q
hp : ↑(monomial (natDegree p)) (leadingCoeff p) + erase (natDegree p) p = p
hq : ↑(monomial (natDegree q)) (leadingCoeff q) + erase (natDegree q) q = q
⊢ WithBot.unbot' 0 (degree p) = WithBot.unbot' 0 (degree q)

tactic: conv =>
  lhs
  rw [← hp, ← hq, hlc, hd', add_sub_add_left_eq_sub, sub_eq_add_neg]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
hd : degree p = degree q
hp0 : p ≠ 0
hlc : leadingCoeff p = leadingCoeff q
hp : ↑(monomial (natDegree p)) (leadingCoeff p) + erase (natDegree p) p = p
hq : ↑(monomial (natDegree q)) (leadingCoeff q) + erase (natDegree q) q = q
hd' : natDegree p = natDegree q
hq0 : q ≠ 0
⊢ degree (p - q) = degree (erase (natDegree q) p + -erase (natDegree q) q)
Theorem: Ordinal.IsNormal.apply_omega
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← sup_nat_cast, IsNormal.sup.{0, u, u} hf]
state_before: f : Ordinal → Ordinal
hf : IsNormal f
⊢ Ordinal.sup (f ∘ Nat.cast) = f ω
Theorem: SimpleGraph.Walk.bypass_isPath
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp!
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ : V
⊢ IsPath (bypass nil)

tactic: simp only [bypass]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : IsPath (bypass p')
⊢ IsPath (bypass (cons h✝ p'))

tactic: split_ifs with hs
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : IsPath (bypass p')
⊢ IsPath (if hs : u✝ ∈ support (bypass p') then dropUntil (bypass p') u✝ hs else cons h✝ (bypass p'))

tactic: exact ih.dropUntil hs
state_before: case cons.inl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : IsPath (bypass p')
hs : u✝ ∈ support (bypass p')
⊢ IsPath (dropUntil (bypass p') u✝ hs)

tactic: simp [*, cons_isPath_iff]
state_before: case cons.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : IsPath (bypass p')
hs : ¬u✝ ∈ support (bypass p')
⊢ IsPath (cons h✝ (bypass p'))
Theorem: Homotopy.map_nullHomotopicMap
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: exact G.map (hom i j)
state_before: ι : Type ?u.262154
V : Type u
inst✝⁴ : Category V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type ?u.262509
inst✝² : Category W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : Functor.Additive G
hom : (i j : ι) → X C i ⟶ X D j
i j : ι
⊢ X ((Functor.mapHomologicalComplex G c).obj C) i ⟶ X ((Functor.mapHomologicalComplex G c).obj D) j

tactic: ext i
state_before: ι : Type u_3
V : Type u
inst✝⁴ : Category V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i : ι
W : Type u_1
inst✝² : Category W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : Functor.Additive G
hom : (i j : ι) → X C i ⟶ X D j
⊢ (Functor.mapHomologicalComplex G c).map (nullHomotopicMap hom) = nullHomotopicMap fun i j => G.map (hom i j)

tactic: dsimp [nullHomotopicMap, dNext, prevD]
state_before: case h
ι : Type u_3
V : Type u
inst✝⁴ : Category V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_1
inst✝² : Category W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : Functor.Additive G
hom : (i j : ι) → X C i ⟶ X D j
i : ι
⊢ Hom.f ((Functor.mapHomologicalComplex G c).map (nullHomotopicMap hom)) i =
    Hom.f (nullHomotopicMap fun i j => G.map (hom i j)) i

tactic: simp only [G.map_comp, Functor.map_add]
state_before: case h
ι : Type u_3
V : Type u
inst✝⁴ : Category V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_1
inst✝² : Category W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : Functor.Additive G
hom : (i j : ι) → X C i ⟶ X D j
i : ι
⊢ G.map
      (d C i (ComplexShape.next c i) ≫ hom (ComplexShape.next c i) i +
        hom i (ComplexShape.prev c i) ≫ d D (ComplexShape.prev c i) i) =
    G.map (d C i (ComplexShape.next c i)) ≫ G.map (hom (ComplexShape.next c i) i) +
      G.map (hom i (ComplexShape.prev c i)) ≫ G.map (d D (ComplexShape.prev c i) i)
Theorem: Nat.sub_eq_zero_of_le
File: src/lean/Init/Data/Nat/Basic.lean

tactic: match le.dest h with
| ⟨k, hk⟩ => rw [← hk, Nat.sub_self_add]
state_before: n m : Nat
h : n ≤ m
⊢ n - m = 0

tactic: rw [← hk, Nat.sub_self_add]
state_before: n m : Nat
h : n ≤ m
k : Nat
hk : n + k = m
⊢ n - m = 0
Theorem: Module.DirectLimit.exists_of
File: Mathlib/Algebra/DirectLimit.lean

tactic: infer_instance
state_before: R : Type u
inst✝⁵ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z : DirectLimit G f
⊢ Nonempty ι

tactic: rw [LinearMap.map_add, of_f, of_f, ihx, ihy]
state_before: R : Type u
inst✝⁵ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z✝ : DirectLimit G f
ind : ι
z p q : ⨁ (i : ι), G i
x✝¹ : ∃ i x, ↑(of R ι G f i) x = Quotient.mk'' p
x✝ : ∃ i x, ↑(of R ι G f i) x = Quotient.mk'' q
i : ι
x : G i
ihx : ↑(of R ι G f i) x = Quotient.mk'' p
j : ι
y : G j
ihy : ↑(of R ι G f j) y = Quotient.mk'' q
k : ι
hik : i ≤ k
hjk : j ≤ k
⊢ ↑(of R ι G f k) (↑(f i k hik) x + ↑(f j k hjk) y) = Quotient.mk'' (p + q)

tactic: simp only [Submodule.Quotient.mk''_eq_mk, Quotient.mk_add]
state_before: R : Type u
inst✝⁵ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (G i)
inst✝² : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
z✝ : DirectLimit G f
ind : ι
z p q : ⨁ (i : ι), G i
x✝¹ : ∃ i x, ↑(of R ι G f i) x = Quotient.mk'' p
x✝ : ∃ i x, ↑(of R ι G f i) x = Quotient.mk'' q
i : ι
x : G i
ihx : ↑(of R ι G f i) x = Quotient.mk'' p
j : ι
y : G j
ihy : ↑(of R ι G f j) y = Quotient.mk'' q
k : ι
hik : i ≤ k
hjk : j ≤ k
⊢ Quotient.mk'' p + Quotient.mk'' q = Quotient.mk'' (p + q)
Theorem: Filter.pure_bind
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Bind.bind, bind, map_pure, join_pure]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.232378
ι : Sort x
a : α
m : α → Filter β
⊢ bind (pure a) m = m a
Theorem: IsSelfAdjoint.isSymmetric
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: intro x y
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1318115
G : Type ?u.1318118
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] E
hA : IsSelfAdjoint A
⊢ LinearMap.IsSymmetric ↑A

tactic: rw_mod_cast [← A.adjoint_inner_right, hA.adjoint_eq]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1318115
G : Type ?u.1318118
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] E
hA : IsSelfAdjoint A
x y : E
⊢ inner (↑↑A x) y = inner x (↑↑A y)
Theorem: MulOpposite.unop_list_prod
File: Mathlib/Data/List/BigOperators/Lemmas.lean

tactic: rw [← op_inj, op_unop, MulOpposite.op_list_prod, map_reverse, map_map, reverse_reverse,
  op_comp_unop, map_id]
state_before: ι : Type ?u.28940
α : Type ?u.28943
M : Type u_1
N : Type ?u.28949
P : Type ?u.28952
M₀ : Type ?u.28955
G : Type ?u.28958
R : Type ?u.28961
inst✝ : Monoid M
l : List Mᵐᵒᵖ
⊢ unop (prod l) = prod (reverse (map unop l))
Theorem: Polynomial.coeff_reflect
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: rcases f with ⟨f⟩
state_before: R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N : ℕ
f : R[X]
i : ℕ
⊢ coeff (reflect N f) i = coeff f (↑(revAt N) i)

tactic: simp only [reflect, coeff]
state_before: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ coeff (reflect N { toFinsupp := f }) i = coeff { toFinsupp := f } (↑(revAt N) i)

tactic: calc
  Finsupp.embDomain (revAt N) f i = Finsupp.embDomain (revAt N) f (revAt N (revAt N i)) := by
    rw [revAt_invol]
  _ = f (revAt N i) := Finsupp.embDomain_apply _ _ _
state_before: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ ↑(embDomain (revAt N) f) i = ↑f (↑(revAt N) i)

tactic: rw [revAt_invol]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ ↑(embDomain (revAt N) f) i = ↑(embDomain (revAt N) f) (↑(revAt N) (↑(revAt N) i))
Theorem: wbtw_zero_one_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Wbtw, affineSegment, Set.mem_image]
state_before: R : Type u_1
V : Type ?u.257226
V' : Type ?u.257229
P : Type ?u.257232
P' : Type ?u.257235
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ Wbtw R 0 x 1 ↔ x ∈ Set.Icc 0 1

tactic: simp_rw [lineMap_apply_ring]
state_before: R : Type u_1
V : Type ?u.257226
V' : Type ?u.257229
P : Type ?u.257232
P' : Type ?u.257235
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (∃ x_1, x_1 ∈ Set.Icc 0 1 ∧ ↑(lineMap 0 1) x_1 = x) ↔ x ∈ Set.Icc 0 1

tactic: simp
state_before: R : Type u_1
V : Type ?u.257226
V' : Type ?u.257229
P : Type ?u.257232
P' : Type ?u.257235
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (∃ x_1, x_1 ∈ Set.Icc 0 1 ∧ (1 - x_1) * 0 + x_1 * 1 = x) ↔ x ∈ Set.Icc 0 1
Theorem: Matrix.det_mvPolynomialX_ne_zero
File: Mathlib/LinearAlgebra/Matrix/MvPolynomial.lean

tactic: intro h_det
state_before: m : Type u_1
n : Type ?u.39994
R : Type u_2
S : Type ?u.40000
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ det (mvPolynomialX m m R) ≠ 0

tactic: have := congr_arg Matrix.det (mvPolynomialX_mapMatrix_eval (1 : Matrix m m R))
state_before: m : Type u_1
n : Type ?u.39994
R : Type u_2
S : Type ?u.40000
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : det (mvPolynomialX m m R) = 0
⊢ False

tactic: rw [det_one, ← RingHom.map_det, h_det, RingHom.map_zero] at this
state_before: m : Type u_1
n : Type ?u.39994
R : Type u_2
S : Type ?u.40000
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : det (mvPolynomialX m m R) = 0
this : det (↑(RingHom.mapMatrix (MvPolynomial.eval fun p => OfNat.ofNat 1 p.fst p.snd)) (mvPolynomialX m m R)) = det 1
⊢ False

tactic: exact zero_ne_one this
state_before: m : Type u_1
n : Type ?u.39994
R : Type u_2
S : Type ?u.40000
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : det (mvPolynomialX m m R) = 0
this : 0 = 1
⊢ False
Theorem: MulMemClass.mul_right_mem_add_closure
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: revert b
state_before: M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
a b : R
ha : a ∈ AddSubmonoid.closure ↑S
hb : b ∈ S
⊢ a * b ∈ AddSubmonoid.closure ↑S

tactic: refine' @AddSubmonoid.closure_induction _ _ _
  (fun z => ∀ (b : R), b ∈ S → z * b ∈ AddSubmonoid.closure S) _ ha _ _ _ <;> clear ha a
state_before: M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
a : R
ha : a ∈ AddSubmonoid.closure ↑S
⊢ ∀ {b : R}, b ∈ S → a * b ∈ AddSubmonoid.closure ↑S

tactic: exact fun r hr b hb => AddSubmonoid.mem_closure.mpr fun y hy => hy (mul_mem hr hb)
state_before: case refine'_1
M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x : R), x ∈ ↑S → (fun z => ∀ (b : R), b ∈ S → z * b ∈ AddSubmonoid.closure ↑S) x

tactic: exact fun b _ => by simp only [zero_mul, (AddSubmonoid.closure (S : Set R)).zero_mem]
state_before: case refine'_2
M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ (fun z => ∀ (b : R), b ∈ S → z * b ∈ AddSubmonoid.closure ↑S) 0

tactic: simp only [zero_mul, (AddSubmonoid.closure (S : Set R)).zero_mem]
state_before: M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
b : R
x✝ : b ∈ S
⊢ 0 * b ∈ AddSubmonoid.closure ↑S

tactic: simp_rw [add_mul]
state_before: case refine'_3
M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x y : R),
    (fun z => ∀ (b : R), b ∈ S → z * b ∈ AddSubmonoid.closure ↑S) x →
      (fun z => ∀ (b : R), b ∈ S → z * b ∈ AddSubmonoid.closure ↑S) y →
        (fun z => ∀ (b : R), b ∈ S → z * b ∈ AddSubmonoid.closure ↑S) (x + y)

tactic: exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr _ hb) (hs _ hb)
state_before: case refine'_3
M : Type u_2
A : Type ?u.256135
B : Type ?u.256138
R : Type u_1
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x y : R),
    (∀ (b : R), b ∈ S → x * b ∈ AddSubmonoid.closure ↑S) →
      (∀ (b : R), b ∈ S → y * b ∈ AddSubmonoid.closure ↑S) → ∀ (b : R), b ∈ S → x * b + y * b ∈ AddSubmonoid.closure ↑S