tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_rightUnitor_hom_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (ρ_ X).hom.fst = (ρ_ X.fst).hom

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).hom.fst = (ρ_ (fst✝, snd✝).fst).hom
Theorem: HasDerivAtFilter.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 : HasDerivAtFilter f f' x L
⊢ HasDerivAtFilter (fun x => c - f x) (-f') x L
Theorem: Real.sqrtTwoAddSeries_step_down
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: apply le_trans hz
state_before: a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
⊢ z ≤ sqrtTwoAddSeries (↑c / ↑d) (n + 1)

tactic: rw [sqrtTwoAddSeries_succ]
state_before: a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
⊢ sqrtTwoAddSeries (↑a / ↑b) n ≤ sqrtTwoAddSeries (↑c / ↑d) (n + 1)

tactic: apply sqrtTwoAddSeries_monotone_left
state_before: a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
⊢ sqrtTwoAddSeries (↑a / ↑b) n ≤ sqrtTwoAddSeries (sqrt (2 + ↑c / ↑d)) n

tactic: apply le_sqrt_of_sq_le
state_before: case h
a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
⊢ ↑a / ↑b ≤ sqrt (2 + ↑c / ↑d)

tactic: have hb' : 0 < (b : ℝ) := Nat.cast_pos.2 hb
state_before: case h.h
a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
⊢ (↑a / ↑b) ^ 2 ≤ 2 + ↑c / ↑d

tactic: have hd' : 0 < (d : ℝ) := Nat.cast_pos.2 hd
state_before: case h.h
a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
hb' : 0 < ↑b
⊢ (↑a / ↑b) ^ 2 ≤ 2 + ↑c / ↑d

tactic: rw [div_pow, add_div_eq_mul_add_div _ _ (ne_of_gt hd'), div_le_div_iff (pow_pos hb' _) hd']
state_before: case h.h
a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
hb' : 0 < ↑b
hd' : 0 < ↑d
⊢ (↑a / ↑b) ^ 2 ≤ 2 + ↑c / ↑d

tactic: exact_mod_cast h
state_before: case h.h
a b c d n : ℕ
z : ℝ
hz : z ≤ sqrtTwoAddSeries (↑a / ↑b) n
hb : 0 < b
hd : 0 < d
h : a ^ 2 * d ≤ (2 * d + c) * b ^ 2
hb' : 0 < ↑b
hd' : 0 < ↑d
⊢ ↑a ^ 2 * ↑d ≤ (2 * ↑d + ↑c) * ↑b ^ 2
Theorem: Option.map_map₂_right_comm
File: Mathlib/Data/Option/NAry.lean

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

tactic: rw [Int.lcm]
state_before: i : ℤ
⊢ lcm i 0 = 0

tactic: apply Nat.lcm_zero_right
state_before: i : ℤ
⊢ Nat.lcm (natAbs i) (natAbs 0) = 0
Theorem: Cardinal.isRegular_aleph_one
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← succ_aleph0]
state_before: α : Type ?u.147584
r : α → α → Prop
⊢ IsRegular (aleph 1)

tactic: exact isRegular_succ le_rfl
state_before: α : Type ?u.147584
r : α → α → Prop
⊢ IsRegular (succ ℵ₀)
Theorem: update_le_update_iff
File: Mathlib/Order/Basic.lean

tactic: simp (config := { contextual := true }) [update_le_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
π : ι → Type u_2
r : α → α → Prop
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Preorder (π i)
x y : (i : ι) → π i
i : ι
a b : π i
⊢ update x i a ≤ update y i b ↔ a ≤ b ∧ ∀ (j : ι), j ≠ i → x j ≤ y j
Theorem: toIocMod_neg'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [neg_neg] using toIocMod_neg hp (-a) (-b)
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (-a) b = p - toIcoMod hp a (-b)
Theorem: Set.cons_mem_subchain_iff
File: Mathlib/Order/Height.lean

tactic: simp only [subchain, mem_setOf_eq, forall_mem_cons, chain'_cons', and_left_comm, and_comm,
  and_assoc]
state_before: α : Type u_1
β : Type ?u.483
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ a :: l ∈ subchain s ↔ a ∈ s ∧ l ∈ subchain s ∧ ∀ (b : α), b ∈ head? l → a < b
Theorem: LinearMap.IsSymmetric.conj_inner_sym
File: Mathlib/Analysis/InnerProductSpace/Symmetric.lean

tactic: rw [hT x y, inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
E' : Type ?u.6247
F : Type ?u.6250
G : Type ?u.6253
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace ℝ E'
T : E →ₗ[𝕜] E
hT : IsSymmetric T
x y : E
⊢ ↑(starRingEnd 𝕜) (inner (↑T x) y) = inner (↑T y) x
Theorem: SimpleGraph.Reachable.elim_path
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: classical exact h.elim fun q => hp q.toPath
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
p : Prop
u v : V
h : Reachable G u v
hp : Path G u v → p
⊢ p

tactic: exact h.elim fun q => hp q.toPath
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
p : Prop
u v : V
h : Reachable G u v
hp : Path G u v → p
⊢ p
Theorem: Finsupp.total_embDomain
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: simp [total_apply, Finsupp.sum, support_embDomain, embDomain_apply]
state_before: α : Type u_1
M : Type ?u.352764
N : Type ?u.352767
P : Type ?u.352770
R : Type u_3
S : Type ?u.352776
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
α' : Type u_2
M' : Type u_4
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : α ↪ α'
l : α →₀ R
⊢ ↑(Finsupp.total α' M' R v') (embDomain f l) = ↑(Finsupp.total α M' R (v' ∘ ↑f)) l
Theorem: linearIndependent_iff_totalOn
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [Finsupp.totalOn, LinearMap.ker, LinearMap.comap_codRestrict, Submodule.map_bot, comap_bot,
  LinearMap.ker_comp, linearIndependent_subtype_disjoint, disjoint_iff_inf_le, ←
  map_comap_subtype, map_le_iff_le_comap, comap_bot, ker_subtype, le_bot_iff]
state_before: ι : Type u'
ι' : Type ?u.203055
R : Type u_2
K : Type ?u.203061
M : Type u_1
M' : Type ?u.203067
M'' : Type ?u.203070
V : Type u
V' : Type ?u.203075
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
⊢ (LinearIndependent R fun x => ↑x) ↔ LinearMap.ker (Finsupp.totalOn M M R id s) = ⊥
Theorem: Path.trans_prod_eq_prod_trans
File: Mathlib/Topology/PathConnected.lean

tactic: ext t <;>
unfold Path.trans <;>
simp only [Path.coe_mk_mk, Path.prod_coe, Function.comp_apply] <;>
split_ifs <;>
rfl
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.392356
γ : Path x y
a₁ a₂ a₃ : X
b₁ b₂ b₃ : Y
γ₁ : Path a₁ a₂
δ₁ : Path a₂ a₃
γ₂ : Path b₁ b₂
δ₂ : Path b₂ b₃
⊢ trans (Path.prod γ₁ γ₂) (Path.prod δ₁ δ₂) = Path.prod (trans γ₁ δ₁) (trans γ₂ δ₂)
Theorem: SimpleGraph.Walk.edges_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [edges, List.map_reverse]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ edges (reverse p) = List.reverse (edges p)
Theorem: SimpleGraph.Walk.transfer_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [he]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
q : Walk G v w
hpq : ∀ (e : Sym2 V), e ∈ edges (append p q) → e ∈ edgeSet H
e : Sym2 V
he : e ∈ edges p
⊢ e ∈ edges (append p q)

tactic: simp [he]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
q : Walk G v w
hpq : ∀ (e : Sym2 V), e ∈ edges (append p q) → e ∈ edgeSet H
e : Sym2 V
he : e ∈ edges q
⊢ e ∈ edges (append p q)

tactic: induction p with
| nil => simp
| cons _ _ ih => simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
q : Walk G v w
hpq : ∀ (e : Sym2 V), e ∈ edges (append p q) → e ∈ edgeSet H
⊢ Walk.transfer (append p q) H hpq =
    append (Walk.transfer p H (_ : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ (e : Sym2 V), e ∈ edges q → e ∈ edgeSet H))

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
u✝ : V
q : Walk G u✝ w
hpq : ∀ (e : Sym2 V), e ∈ edges (append nil q) → e ∈ edgeSet H
⊢ Walk.transfer (append nil q) H hpq =
    append (Walk.transfer nil H (_ : ∀ (e : Sym2 V), e ∈ edges nil → e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ (e : Sym2 V), e ∈ edges q → e ∈ edgeSet H))

tactic: simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (q : Walk G w✝ w) (hpq : ∀ (e : Sym2 V), e ∈ edges (append p✝ q) → e ∈ edgeSet H),
    Walk.transfer (append p✝ q) H hpq =
      append (Walk.transfer p✝ H (_ : ∀ (e : Sym2 V), e ∈ edges p✝ → e ∈ edgeSet H))
        (Walk.transfer q H (_ : ∀ (e : Sym2 V), e ∈ edges q → e ∈ edgeSet H))
q : Walk G w✝ w
hpq : ∀ (e : Sym2 V), e ∈ edges (append (cons h✝ p✝) q) → e ∈ edgeSet H
⊢ Walk.transfer (append (cons h✝ p✝) q) H hpq =
    append (Walk.transfer (cons h✝ p✝) H (_ : ∀ (e : Sym2 V), e ∈ edges (cons h✝ p✝) → e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ (e : Sym2 V), e ∈ edges q → e ∈ edgeSet H))
Theorem: Sum.not_isLeft
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.6451
δ : Type ?u.6454
x✝ y x : α ⊕ β
⊢ (!isLeft x) = isRight x
Theorem: Polynomial.exists_root_of_degree_eq_one
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: have : p.coeff 1 ≠ 0 := by
  have h' := natDegree_eq_of_degree_eq_some h
  change natDegree p = 1 at h'; rw [←h']
  exact mt leadingCoeff_eq_zero.1 fun h0 => by simp [h0] at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
⊢ IsRoot p (-(coeff p 0 / coeff p 1))

tactic: conv in p => rw [eq_X_add_C_of_degree_le_one (show degree p ≤ 1 by rw [h])]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
this : coeff p 1 ≠ 0
⊢ IsRoot p (-(coeff p 0 / coeff p 1))

tactic: simp [IsRoot, mul_div_cancel' _ this]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
this : coeff p 1 ≠ 0
⊢ IsRoot (↑C (coeff p 1) * X + ↑C (coeff p 0)) (-(coeff p 0 / coeff p 1))

tactic: have h' := natDegree_eq_of_degree_eq_some h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
⊢ coeff p 1 ≠ 0

tactic: change natDegree p = 1 at h'
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
h' : natDegree p = One.one
⊢ coeff p 1 ≠ 0

tactic: rw [←h']
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
h' : natDegree p = 1
⊢ coeff p 1 ≠ 0

tactic: exact mt leadingCoeff_eq_zero.1 fun h0 => by simp [h0] at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
h' : natDegree p = 1
⊢ coeff p (natDegree p) ≠ 0

tactic: simp [h0] at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
h' : natDegree p = 1
h0 : p = 0
⊢ False

tactic: rw [h]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 1
this : coeff p 1 ≠ 0
⊢ degree p ≤ 1
Theorem: Dfinsupp.mapRange_smul
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: ext
state_before: ι : Type u_4
R : Type u_3
S : Type ?u.109793
M : ι → Type ?u.109798
N : Type ?u.109801
dec_ι : DecidableEq ι
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : ι) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → Module R (M i)
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
β : ι → Type ?u.109888
β₁ : ι → Type u_2
β₂ : ι → Type u_1
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
inst✝⁴ : (i : ι) → AddCommMonoid (β₁ i)
inst✝³ : (i : ι) → AddCommMonoid (β₂ i)
inst✝² : (i : ι) → Module R (β i)
inst✝¹ : (i : ι) → Module R (β₁ i)
inst✝ : (i : ι) → Module R (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
r : R
hf' : ∀ (i : ι) (x : β₁ i), f i (r • x) = r • f i x
g : Π₀ (i : ι), β₁ i
⊢ mapRange f hf (r • g) = r • mapRange f hf g

tactic: simp only [mapRange_apply f, coe_smul, Pi.smul_apply, hf']
state_before: case h
ι : Type u_4
R : Type u_3
S : Type ?u.109793
M : ι → Type ?u.109798
N : Type ?u.109801
dec_ι : DecidableEq ι
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : ι) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → Module R (M i)
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
β : ι → Type ?u.109888
β₁ : ι → Type u_2
β₂ : ι → Type u_1
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
inst✝⁴ : (i : ι) → AddCommMonoid (β₁ i)
inst✝³ : (i : ι) → AddCommMonoid (β₂ i)
inst✝² : (i : ι) → Module R (β i)
inst✝¹ : (i : ι) → Module R (β₁ i)
inst✝ : (i : ι) → Module R (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
r : R
hf' : ∀ (i : ι) (x : β₁ i), f i (r • x) = r • f i x
g : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ ↑(mapRange f hf (r • g)) i✝ = ↑(r • mapRange f hf g) i✝
Theorem: Decidable.List.eq_or_ne_mem_of_mem
File: Mathlib/Data/List/Basic.lean

tactic: by_cases hab : a = b
state_before: ι : Type ?u.979
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
h : a ∈ b :: l
⊢ a = b ∨ a ≠ b ∧ a ∈ l

tactic: exact Or.inl hab
state_before: case pos
ι : Type ?u.979
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
h : a ∈ b :: l
hab : a = b
⊢ a = b ∨ a ≠ b ∧ a ∈ l

tactic: exact ((List.mem_cons.1 h).elim Or.inl (fun h => Or.inr ⟨hab, h⟩))
state_before: case neg
ι : Type ?u.979
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
h : a ∈ b :: l
hab : ¬a = b
⊢ a = b ∨ a ≠ b ∧ a ∈ l
Theorem: MeasureTheory.VectorMeasure.coe_injective
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: cases v
state_before: α : Type u_2
β : Type ?u.7089
m : MeasurableSpace α
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
h : ↑v = ↑w
⊢ v = w

tactic: cases w
state_before: case mk
α : Type u_2
β : Type ?u.7089
m : MeasurableSpace α
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
w : VectorMeasure α M
measureOf'✝ : Set α → M
empty'✝ : measureOf'✝ ∅ = 0
not_measurable'✝ : ∀ ⦃i : Set α⦄, ¬MeasurableSet i → measureOf'✝ i = 0
m_iUnion'✝ :
  ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) →
      Pairwise (Disjoint on f) → HasSum (fun i => measureOf'✝ (f i)) (measureOf'✝ (⋃ (i : ℕ), f i))
h : ↑{ measureOf' := measureOf'✝, empty' := empty'✝, not_measurable' := not_measurable'✝, m_iUnion' := m_iUnion'✝ } = ↑w
⊢ { measureOf' := measureOf'✝, empty' := empty'✝, not_measurable' := not_measurable'✝, m_iUnion' := m_iUnion'✝ } = w

tactic: congr
state_before: case mk.mk
α : Type u_2
β : Type ?u.7089
m : MeasurableSpace α
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
measureOf'✝¹ : Set α → M
empty'✝¹ : measureOf'✝¹ ∅ = 0
not_measurable'✝¹ : ∀ ⦃i : Set α⦄, ¬MeasurableSet i → measureOf'✝¹ i = 0
m_iUnion'✝¹ :
  ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) →
      Pairwise (Disjoint on f) → HasSum (fun i => measureOf'✝¹ (f i)) (measureOf'✝¹ (⋃ (i : ℕ), f i))
measureOf'✝ : Set α → M
empty'✝ : measureOf'✝ ∅ = 0
not_measurable'✝ : ∀ ⦃i : Set α⦄, ¬MeasurableSet i → measureOf'✝ i = 0
m_iUnion'✝ :
  ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) →
      Pairwise (Disjoint on f) → HasSum (fun i => measureOf'✝ (f i)) (measureOf'✝ (⋃ (i : ℕ), f i))
h :
  ↑{ measureOf' := measureOf'✝¹, empty' := empty'✝¹, not_measurable' := not_measurable'✝¹, m_iUnion' := m_iUnion'✝¹ } =
    ↑{ measureOf' := measureOf'✝, empty' := empty'✝, not_measurable' := not_measurable'✝, m_iUnion' := m_iUnion'✝ }
⊢ { measureOf' := measureOf'✝¹, empty' := empty'✝¹, not_measurable' := not_measurable'✝¹, m_iUnion' := m_iUnion'✝¹ } =
    { measureOf' := measureOf'✝, empty' := empty'✝, not_measurable' := not_measurable'✝, m_iUnion' := m_iUnion'✝ }
Theorem: CategoryTheory.essentiallySmall_congr
File: Mathlib/CategoryTheory/EssentiallySmall.lean

tactic: fconstructor
state_before: C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
⊢ EssentiallySmall C ↔ EssentiallySmall D

tactic: rintro ⟨S, 𝒮, ⟨f⟩⟩
state_before: case mp
C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
⊢ EssentiallySmall C → EssentiallySmall D

tactic: skip
state_before: case mp.mk.intro.intro.intro
C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
S : Type w
𝒮 : SmallCategory S
f : C ≌ S
⊢ EssentiallySmall D

tactic: exact EssentiallySmall.mk' (e.symm.trans f)
state_before: case mp.mk.intro.intro.intro
C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
S : Type w
𝒮 : SmallCategory S
f : C ≌ S
⊢ EssentiallySmall D

tactic: rintro ⟨S, 𝒮, ⟨f⟩⟩
state_before: case mpr
C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
⊢ EssentiallySmall D → EssentiallySmall C

tactic: skip
state_before: case mpr.mk.intro.intro.intro
C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
S : Type w
𝒮 : SmallCategory S
f : D ≌ S
⊢ EssentiallySmall C

tactic: exact EssentiallySmall.mk' (e.trans f)
state_before: case mpr.mk.intro.intro.intro
C✝ : Type u
inst✝² : Category C✝
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
e : C ≌ D
S : Type w
𝒮 : SmallCategory S
f : D ≌ S
⊢ EssentiallySmall C
Theorem: Finsupp.some_single_none
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext
state_before: α : Type u_2
β : Type ?u.324241
γ : Type ?u.324244
ι : Type ?u.324247
M : Type u_1
M' : Type ?u.324253
N : Type ?u.324256
P : Type ?u.324259
G : Type ?u.324262
H : Type ?u.324265
R : Type ?u.324268
S : Type ?u.324271
inst✝ : Zero M
m : M
⊢ some (single none m) = 0

tactic: simp
state_before: case h
α : Type u_2
β : Type ?u.324241
γ : Type ?u.324244
ι : Type ?u.324247
M : Type u_1
M' : Type ?u.324253
N : Type ?u.324256
P : Type ?u.324259
G : Type ?u.324262
H : Type ?u.324265
R : Type ?u.324268
S : Type ?u.324271
inst✝ : Zero M
m : M
a✝ : α
⊢ ↑(some (single none m)) a✝ = ↑0 a✝
Theorem: Ideal.IsHomogeneous.iff_exists
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rw [Ideal.IsHomogeneous.iff_eq, eq_comm]
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.110347
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ IsHomogeneous 𝒜 I ↔ ∃ S, I = span (Subtype.val '' S)

tactic: exact ((Set.image_preimage.compose (Submodule.gi _ _).gc).exists_eq_l _).symm
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.110347
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ I = HomogeneousIdeal.toIdeal (homogeneousCore 𝒜 I) ↔ ∃ S, I = span (Subtype.val '' S)
Theorem: LinearMap.toMatrix₂_mul_basis_toMatrix
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp_rw [← LinearMap.toMatrix_id_eq_basis_toMatrix]
state_before: R : Type u_2
R₁ : Type ?u.1708981
R₂ : Type ?u.1708984
M : Type ?u.1708987
M₁ : Type u_3
M₂ : Type u_5
M₁' : Type ?u.1708996
M₂' : Type ?u.1708999
n : Type u_7
m : Type u_6
n' : Type u_1
m' : Type u_4
ι : Type ?u.1709014
inst✝¹⁶ : CommRing R
inst✝¹⁵ : AddCommMonoid M₁
inst✝¹⁴ : Module R M₁
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R M₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
c₁ : Basis n' R M₁
c₂ : Basis m' R M₂
B : M₁ →ₗ[R] M₂ →ₗ[R] R
⊢ (Basis.toMatrix b₁ ↑c₁)ᵀ ⬝ ↑(toMatrix₂ b₁ b₂) B ⬝ Basis.toMatrix b₂ ↑c₂ = ↑(toMatrix₂ c₁ c₂) B

tactic: rw [← LinearMap.toMatrix₂_compl₁₂, LinearMap.compl₁₂_id_id]
state_before: R : Type u_2
R₁ : Type ?u.1708981
R₂ : Type ?u.1708984
M : Type ?u.1708987
M₁ : Type u_3
M₂ : Type u_5
M₁' : Type ?u.1708996
M₂' : Type ?u.1708999
n : Type u_7
m : Type u_6
n' : Type u_1
m' : Type u_4
ι : Type ?u.1709014
inst✝¹⁶ : CommRing R
inst✝¹⁵ : AddCommMonoid M₁
inst✝¹⁴ : Module R M₁
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R M₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
c₁ : Basis n' R M₁
c₂ : Basis m' R M₂
B : M₁ →ₗ[R] M₂ →ₗ[R] R
⊢ (↑(toMatrix c₁ b₁) id)ᵀ ⬝ ↑(toMatrix₂ b₁ b₂) B ⬝ ↑(toMatrix c₂ b₂) id = ↑(toMatrix₂ c₁ c₂) B
Theorem: LieSubmodule.homOfLe_injective
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp only [homOfLe_apply, imp_self, Subtype.mk_eq_mk, SetLike.coe_eq_coe]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
h : N ≤ N'
x y : { x // x ∈ ↑N }
⊢ ↑(homOfLe h) x = ↑(homOfLe h) y → x = y