tasksource/leandojo huggingface dataset:
Theorem: List.not_mem_keys_kerase
File: Mathlib/Data/List/Sigma.lean

tactic: induction l
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
nd : NodupKeys l
⊢ ¬a ∈ keys (kerase a l)

tactic: case nil => simp
state_before: case nil
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
nd : NodupKeys []
⊢ ¬a ∈ keys (kerase a [])

case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
tail✝ : List (Sigma β)
tail_ih✝ : NodupKeys tail✝ → ¬a ∈ keys (kerase a tail✝)
nd : NodupKeys (head✝ :: tail✝)
⊢ ¬a ∈ keys (kerase a (head✝ :: tail✝))

tactic: simp
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
nd : NodupKeys []
⊢ ¬a ∈ keys (kerase a [])

tactic: simp at nd
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
hd : Sigma β
tl : List (Sigma β)
ih : NodupKeys tl → ¬a ∈ keys (kerase a tl)
nd : NodupKeys (hd :: tl)
⊢ ¬a ∈ keys (kerase a (hd :: tl))

tactic: by_cases h : a = hd.1
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
hd : Sigma β
tl : List (Sigma β)
ih : NodupKeys tl → ¬a ∈ keys (kerase a tl)
nd : ¬hd.fst ∈ keys tl ∧ NodupKeys tl
⊢ ¬a ∈ keys (kerase a (hd :: tl))

tactic: subst h
state_before: case pos
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
hd : Sigma β
tl : List (Sigma β)
ih : NodupKeys tl → ¬a ∈ keys (kerase a tl)
nd : ¬hd.fst ∈ keys tl ∧ NodupKeys tl
h : a = hd.fst
⊢ ¬a ∈ keys (kerase a (hd :: tl))

tactic: simp [nd.1]
state_before: case pos
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
hd : Sigma β
tl : List (Sigma β)
nd : ¬hd.fst ∈ keys tl ∧ NodupKeys tl
ih : NodupKeys tl → ¬hd.fst ∈ keys (kerase hd.fst tl)
⊢ ¬hd.fst ∈ keys (kerase hd.fst (hd :: tl))

tactic: simp [h, ih nd.2]
state_before: case neg
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
hd : Sigma β
tl : List (Sigma β)
ih : NodupKeys tl → ¬a ∈ keys (kerase a tl)
nd : ¬hd.fst ∈ keys tl ∧ NodupKeys tl
h : ¬a = hd.fst
⊢ ¬a ∈ keys (kerase a (hd :: tl))
Theorem: vectorSpan_eq_span_vsub_set_left_ne
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: conv_lhs =>
  rw [vectorSpan_eq_span_vsub_set_left k hp, ← Set.insert_eq_of_mem hp, ←
    Set.insert_diff_singleton, Set.image_insert_eq]
state_before: k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.258427
s : Set P
p : P
hp : p ∈ s
⊢ vectorSpan k s = Submodule.span k ((fun x x_1 => x -ᵥ x_1) p '' (s \ {p}))

tactic: simp [Submodule.span_insert_eq_span]
state_before: k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.258427
s : Set P
p : P
hp : p ∈ s
⊢ Submodule.span k (insert ((fun x x_1 => x -ᵥ x_1) p p) ((fun x x_1 => x -ᵥ x_1) p '' (s \ {p}))) =
    Submodule.span k ((fun x x_1 => x -ᵥ x_1) p '' (s \ {p}))
Theorem: ENNReal.rpow_two
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← rpow_nat_cast]
state_before: x : ℝ≥0∞
⊢ x ^ 2 = x ^ 2

tactic: simp only [Nat.cast_ofNat]
state_before: x : ℝ≥0∞
⊢ x ^ 2 = x ^ ↑2
Theorem: Submodule.span_smul_eq_of_isUnit
File: Mathlib/LinearAlgebra/Span.lean

tactic: apply le_antisymm
state_before: R : Type u_2
R₂ : Type ?u.69448
K : Type ?u.69451
M : Type u_1
M₂ : Type ?u.69457
V : Type ?u.69460
S : Type ?u.69463
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t s : Set M
r : R
hr : IsUnit r
⊢ span R (r • s) = span R s

tactic: apply span_smul_le
state_before: case a
R : Type u_2
R₂ : Type ?u.69448
K : Type ?u.69451
M : Type u_1
M₂ : Type ?u.69457
V : Type ?u.69460
S : Type ?u.69463
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t s : Set M
r : R
hr : IsUnit r
⊢ span R (r • s) ≤ span R s

tactic: convert span_smul_le (r • s) ((hr.unit⁻¹ : _) : R)
state_before: case a
R : Type u_2
R₂ : Type ?u.69448
K : Type ?u.69451
M : Type u_1
M₂ : Type ?u.69457
V : Type ?u.69460
S : Type ?u.69463
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t s : Set M
r : R
hr : IsUnit r
⊢ span R s ≤ span R (r • s)

tactic: rw [smul_smul]
state_before: case h.e'_3.h.e'_6
R : Type u_2
R₂ : Type ?u.69448
K : Type ?u.69451
M : Type u_1
M₂ : Type ?u.69457
V : Type ?u.69460
S : Type ?u.69463
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t s : Set M
r : R
hr : IsUnit r
⊢ s = ↑(IsUnit.unit hr)⁻¹ • r • s

tactic: erw [hr.unit.inv_val]
state_before: case h.e'_3.h.e'_6
R : Type u_2
R₂ : Type ?u.69448
K : Type ?u.69451
M : Type u_1
M₂ : Type ?u.69457
V : Type ?u.69460
S : Type ?u.69463
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t s : Set M
r : R
hr : IsUnit r
⊢ s = (↑(IsUnit.unit hr)⁻¹ * r) • s

tactic: rw [one_smul]
state_before: case h.e'_3.h.e'_6
R : Type u_2
R₂ : Type ?u.69448
K : Type ?u.69451
M : Type u_1
M₂ : Type ?u.69457
V : Type ?u.69460
S : Type ?u.69463
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t s : Set M
r : R
hr : IsUnit r
⊢ s = 1 • s
Theorem: pochhammer_nat_eval_succ
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: by_cases h : r = 0
state_before: S : Type ?u.31829
inst✝ : Semiring S
r✝ n r : ℕ
⊢ 0 * eval (0 + 1) (pochhammer ℕ r) = (0 + r) * eval 0 (pochhammer ℕ r)

tactic: simp only [h, zero_mul, zero_add]
state_before: case pos
S : Type ?u.31829
inst✝ : Semiring S
r✝ n r : ℕ
h : r = 0
⊢ 0 * eval (0 + 1) (pochhammer ℕ r) = (0 + r) * eval 0 (pochhammer ℕ r)

tactic: simp only [pochhammer_eval_zero, zero_mul, if_neg h, mul_zero]
state_before: case neg
S : Type ?u.31829
inst✝ : Semiring S
r✝ n r : ℕ
h : ¬r = 0
⊢ 0 * eval (0 + 1) (pochhammer ℕ r) = (0 + r) * eval 0 (pochhammer ℕ r)

tactic: simp only [pochhammer_nat_eq_ascFactorial, Nat.succ_ascFactorial, add_right_comm]
state_before: S : Type ?u.31829
inst✝ : Semiring S
r✝ n r k : ℕ
⊢ (k + 1) * eval (k + 1 + 1) (pochhammer ℕ r) = (k + 1 + r) * eval (k + 1) (pochhammer ℕ r)
Theorem: Nat.fold_eq_foldTR
File: src/lean/Init/Data/Nat/Basic.lean

tactic: simp [foldTR.loop]
state_before: α : Type u_1
f : Nat → α → α
n✝ : Nat
init : α
n : Nat
⊢ foldTR.loop f (0 + n) 0 (fold f n init) = fold f (0 + n) init

tactic: rw [foldTR.loop, add_sub_self_left, succ_add]
state_before: α : Type u_1
f : Nat → α → α
n✝ : Nat
init : α
m n : Nat
⊢ foldTR.loop f (succ m + n) (succ m) (fold f n init) = fold f (succ m + n) init

tactic: exact go m (succ n)
state_before: α : Type u_1
f : Nat → α → α
n✝ : Nat
init : α
m n : Nat
⊢ foldTR.loop f (succ (m + n)) m (f n (fold f n init)) = fold f (succ (m + n)) init
Theorem: Ideal.span_singleton_mul_right_unit
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [mul_comm, span_singleton_mul_left_unit h2]
state_before: α : Type u
β : Type v
a✝ b : α
inst✝ : CommSemiring α
I : Ideal α
a : α
h2 : IsUnit a
x : α
⊢ span {x * a} = span {x}
Theorem: Finset.image_id
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [mem_image, exists_prop, id, exists_eq_right]
state_before: α : Type u_1
β : Type ?u.77099
γ : Type ?u.77102
inst✝¹ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq α
x✝ : α
⊢ x✝ ∈ image id s ↔ x✝ ∈ s
Theorem: AffineIndependent.mem_affineSpan_iff
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: constructor
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i : ι
s : Set ι
⊢ p i ∈ affineSpan k (p '' s) ↔ i ∈ s

tactic: intro hs
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i : ι
s : Set ι
⊢ p i ∈ affineSpan k (p '' s) → i ∈ s

tactic: have h :=
  AffineIndependent.exists_mem_inter_of_exists_mem_inter_affineSpan ha hs
    (mem_affineSpan k (Set.mem_image_of_mem _ (Set.mem_singleton _)))
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i : ι
s : Set ι
hs : p i ∈ affineSpan k (p '' s)
⊢ i ∈ s

tactic: rwa [← Set.nonempty_def, Set.inter_singleton_nonempty] at h
state_before: case mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i : ι
s : Set ι
hs : p i ∈ affineSpan k (p '' s)
h : ∃ i_1, i_1 ∈ s ∩ {i}
⊢ i ∈ s

tactic: exact fun h => mem_affineSpan k (Set.mem_image_of_mem p h)
state_before: case mpr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
i : ι
s : Set ι
⊢ i ∈ s → p i ∈ affineSpan k (p '' s)
Theorem: Commute.div_left
File: Mathlib/Algebra/GroupWithZero/Commute.lean

tactic: rw [div_eq_mul_inv]
state_before: α : Type ?u.2754
M₀ : Type ?u.2757
G₀ : Type u_1
M₀' : Type ?u.2763
G₀' : Type ?u.2766
F : Type ?u.2769
F' : Type ?u.2772
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c : G₀
hac : Commute a c
hbc : Commute b c
⊢ Commute (a / b) c

tactic: exact hac.mul_left hbc.inv_left₀
state_before: α : Type ?u.2754
M₀ : Type ?u.2757
G₀ : Type u_1
M₀' : Type ?u.2763
G₀' : Type ?u.2766
F : Type ?u.2769
F' : Type ?u.2772
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c : G₀
hac : Commute a c
hbc : Commute b c
⊢ Commute (a * b⁻¹) c
Theorem: Submodule.finrank_add_finrank_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: convert Submodule.finrank_add_inf_finrank_orthogonal (le_top : K ≤ ⊤) using 1
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1005430
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K✝ : Submodule 𝕜 E
inst✝ : FiniteDimensional 𝕜 E
K : Submodule 𝕜 E
⊢ finrank 𝕜 { x // x ∈ K } + finrank 𝕜 { x // x ∈ Kᗮ } = finrank 𝕜 E

tactic: rw [inf_top_eq]
state_before: case h.e'_2
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1005430
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K✝ : Submodule 𝕜 E
inst✝ : FiniteDimensional 𝕜 E
K : Submodule 𝕜 E
⊢ finrank 𝕜 { x // x ∈ K } + finrank 𝕜 { x // x ∈ Kᗮ } = finrank 𝕜 { x // x ∈ K } + finrank 𝕜 { x // x ∈ Kᗮ ⊓ ⊤ }

tactic: simp
state_before: case h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1005430
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K✝ : Submodule 𝕜 E
inst✝ : FiniteDimensional 𝕜 E
K : Submodule 𝕜 E
⊢ finrank 𝕜 E = finrank 𝕜 { x // x ∈ ⊤ }
Theorem: EMetric.diam_pi_le_of_le
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: refine diam_le fun x hx y hy => edist_pi_le_iff.mpr ?_
state_before: α : Type u
β : Type v
X : Type ?u.307283
inst✝² : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), diam (s b) ≤ c
⊢ diam (Set.pi univ s) ≤ c

tactic: rw [mem_univ_pi] at hx hy
state_before: α : Type u
β : Type v
X : Type ?u.307283
inst✝² : PseudoEMetricSpace α
x✝ y✝ z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), diam (s b) ≤ c
x : (i : β) → π i
hx : x ∈ Set.pi univ s
y : (i : β) → π i
hy : y ∈ Set.pi univ s
⊢ ∀ (b : β), edist (x b) (y b) ≤ c

tactic: exact fun b => diam_le_iff.1 (h b) (x b) (hx b) (y b) (hy b)
state_before: α : Type u
β : Type v
X : Type ?u.307283
inst✝² : PseudoEMetricSpace α
x✝ y✝ z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), diam (s b) ≤ c
x : (i : β) → π i
hx : ∀ (i : β), x i ∈ s i
y : (i : β) → π i
hy : ∀ (i : β), y i ∈ s i
⊢ ∀ (b : β), edist (x b) (y b) ≤ c
Theorem: pow_pos_iff
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simp_rw [zero_lt_iff]
state_before: β : Type ?u.274493
A : Type ?u.274496
G : Type ?u.274499
M : Type u_1
R : Type ?u.274505
inst✝¹ : LinearOrderedCommMonoidWithZero M
inst✝ : NoZeroDivisors M
a : M
n : ℕ
hn : 0 < n
⊢ 0 < a ^ n ↔ 0 < a

tactic: rw [pow_ne_zero_iff hn]
state_before: β : Type ?u.274493
A : Type ?u.274496
G : Type ?u.274499
M : Type u_1
R : Type ?u.274505
inst✝¹ : LinearOrderedCommMonoidWithZero M
inst✝ : NoZeroDivisors M
a : M
n : ℕ
hn : 0 < n
⊢ a ^ n ≠ 0 ↔ a ≠ 0
Theorem: LieAlgebra.Orthogonal.jb_transform
File: Mathlib/Algebra/Lie/Classical.lean

tactic: simp [PB, JB, jd_transform, Matrix.fromBlocks_transpose, Matrix.fromBlocks_multiply,
  Matrix.fromBlocks_smul]
state_before: n : Type ?u.156835
p : Type ?u.156838
q : Type ?u.156841
l : Type u_1
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
⊢ (PB l R)ᵀ ⬝ JB l R ⬝ PB l R = 2 • fromBlocks 1 0 0 (S l R)
Theorem: Polynomial.coeff_zero_eq_aeval_zero'
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: simp [aeval_def]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type ?u.1127963
B' : Type ?u.1127966
a b : R
n : ℕ
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B'
inst✝⁴ : CommSemiring R
p✝ q : R[X]
inst✝³ : Semiring A
inst✝² : Algebra R A
B : Type ?u.1128179
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A
p : R[X]
⊢ ↑(algebraMap R A) (coeff p 0) = ↑(aeval 0) p
Theorem: HomologicalComplex.singleMapHomologicalComplex_hom_app_self
File: Mathlib/Algebra/Homology/Additive.lean

tactic: simp
state_before: ι : Type ?u.156859
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 : ι
inst✝⁴ : HasZeroObject V
W : Type ?u.157228
inst✝³ : Category W
inst✝² : Preadditive W
inst✝¹ : HasZeroObject W
F : V ⥤ W
inst✝ : Functor.Additive F
j : ι
X : V
⊢ HomologicalComplex.X ((single V c j ⋙ Functor.mapHomologicalComplex F c).obj X) j =
    HomologicalComplex.X ((F ⋙ single W c j).obj X) j

tactic: simp [singleMapHomologicalComplex]
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 : ι
inst✝⁴ : HasZeroObject V
W : Type u_2
inst✝³ : Category W
inst✝² : Preadditive W
inst✝¹ : HasZeroObject W
F : V ⥤ W
inst✝ : Functor.Additive F
j : ι
X : V
⊢ Hom.f ((singleMapHomologicalComplex F c j).hom.app X) j =
    eqToHom (_ : F.obj (if j = j then X else 0) = if j = j then F.obj X else 0)
Theorem: fderivWithin_neg
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt h,
  fderivWithin_zero_of_not_differentiableWithinAt, neg_zero]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.431682
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.431777
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hxs : UniqueDiffWithinAt 𝕜 s x
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ fderivWithin 𝕜 (fun y => -f y) s x = -fderivWithin 𝕜 f s x

tactic: simpa
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.431682
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.431777
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hxs : UniqueDiffWithinAt 𝕜 s x
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ ¬DifferentiableWithinAt 𝕜 (fun y => -f y) s x
Theorem: mem_exposedPoints_iff_exposed_singleton
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: use fun ⟨hxA, l, hl⟩ _ =>
  ⟨l,
    Eq.symm <|
      eq_singleton_iff_unique_mem.2
        ⟨⟨hxA, fun y hy => (hl y hy).1⟩, fun z hz => (hl z hz.1).2 (hz.2 x hxA)⟩⟩
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
⊢ x ∈ exposedPoints 𝕜 A ↔ IsExposed 𝕜 A {x}

tactic: rintro h
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
⊢ IsExposed 𝕜 A {x} → x ∈ exposedPoints 𝕜 A

tactic: obtain ⟨l, hl⟩ := h ⟨x, mem_singleton _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
h : IsExposed 𝕜 A {x}
⊢ x ∈ exposedPoints 𝕜 A

tactic: rw [eq_comm, eq_singleton_iff_unique_mem] at hl
state_before: case intro
𝕜 : Type u_2
E : Type u_1
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
h : IsExposed 𝕜 A {x}
l : E →L[𝕜] 𝕜
hl : {x} = {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}
⊢ x ∈ exposedPoints 𝕜 A

tactic: exact
  ⟨hl.1.1, l, fun y hy =>
    ⟨hl.1.2 y hy, fun hxy => hl.2 y ⟨hy, fun z hz => (hl.1.2 z hz).trans hxy⟩⟩⟩
state_before: case intro
𝕜 : Type u_2
E : Type u_1
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
h : IsExposed 𝕜 A {x}
l : E →L[𝕜] 𝕜
hl :
  x ∈ {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x} ∧
    ∀ (x_1 : E), x_1 ∈ {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x} → x_1 = x
⊢ x ∈ exposedPoints 𝕜 A
Theorem: CategoryTheory.Limits.PushoutCocone.unop_snd
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category C
J : Type u₂
inst✝ : Category J
X✝ : Type v₂
X Y Z : Cᵒᵖ
f : X ⟶ Y
g : X ⟶ Z
c : PushoutCocone f g
⊢ PullbackCone.snd (unop c) = (inr c).unop
Theorem: pairwise_coprime_iff_coprime_prod
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: refine' ⟨fun hp i hi ↦ IsCoprime.prod_right_iff.mpr fun j hj ↦ ?_, fun hp ↦ ?_⟩
state_before: R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
⊢ Pairwise (IsCoprime on fun i => s ↑i) ↔ ∀ (i : I), i ∈ t → IsCoprime (s i) (∏ j in t \ {i}, s j)

tactic: rw [Finset.mem_sdiff, Finset.mem_singleton] at hj
state_before: case refine'_1
R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
hp : Pairwise (IsCoprime on fun i => s ↑i)
i : I
hi : i ∈ t
j : I
hj : j ∈ t \ {i}
⊢ IsCoprime (s i) (s j)

tactic: obtain ⟨hj, ji⟩ := hj
state_before: case refine'_1
R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
hp : Pairwise (IsCoprime on fun i => s ↑i)
i : I
hi : i ∈ t
j : I
hj : j ∈ t ∧ ¬j = i
⊢ IsCoprime (s i) (s j)

tactic: refine @hp ⟨i, hi⟩ ⟨j, hj⟩ fun h ↦ ji (congrArg Subtype.val h).symm
state_before: case refine'_1.intro
R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
hp : Pairwise (IsCoprime on fun i => s ↑i)
i : I
hi : i ∈ t
j : I
hj : j ∈ t
ji : ¬j = i
⊢ IsCoprime (s i) (s j)

tactic: rintro ⟨i, hi⟩ ⟨j, hj⟩ h
state_before: case refine'_2
R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
hp : ∀ (i : I), i ∈ t → IsCoprime (s i) (∏ j in t \ {i}, s j)
⊢ Pairwise (IsCoprime on fun i => s ↑i)

tactic: apply IsCoprime.prod_right_iff.mp (hp i hi)
state_before: case refine'_2.mk.mk
R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
hp : ∀ (i : I), i ∈ t → IsCoprime (s i) (∏ j in t \ {i}, s j)
i : I
hi : i ∈ t
j : I
hj : j ∈ t
h : { val := i, property := hi } ≠ { val := j, property := hj }
⊢ (IsCoprime on fun i => s ↑i) { val := i, property := hi } { val := j, property := hj }

tactic: exact Finset.mem_sdiff.mpr ⟨hj, fun f ↦ h <| Subtype.ext (Finset.mem_singleton.mp f).symm⟩
state_before: case refine'_2.mk.mk.a
R : Type u
I : Type v
inst✝¹ : CommSemiring R
x y z : R
s : I → R
t : Finset I
inst✝ : DecidableEq I
hp : ∀ (i : I), i ∈ t → IsCoprime (s i) (∏ j in t \ {i}, s j)
i : I
hi : i ∈ t
j : I
hj : j ∈ t
h : { val := i, property := hi } ≠ { val := j, property := hj }
⊢ ↑{ val := j, property := hj } ∈ t \ {i}
Theorem: ZMod.val_lt
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ val a < n

tactic: exact Fin.is_lt a
state_before: case succ
n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
a : ZMod (Nat.succ n✝)
⊢ val a < Nat.succ n✝

tactic: cases NeZero.ne 0 rfl
state_before: case zero
inst✝ : NeZero Nat.zero
a : ZMod Nat.zero
⊢ val a < Nat.zero
Theorem: Order.Ideal.PrimePair.I_isProper
File: Mathlib/Order/PrimeIdeal.lean

tactic: cases' IF.F.nonempty with w h
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
⊢ IsProper IF.I

tactic: apply isProper_of_not_mem (_ : w ∉ IF.I)
state_before: case intro
P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
w : P
h : w ∈ ↑IF.F
⊢ IsProper IF.I

tactic: rwa [← IF.compl_I_eq_F] at h
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
w : P
h : w ∈ ↑IF.F
⊢ ¬w ∈ IF.I
Theorem: Multiset.singleton_eq_cons_iff
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← cons_zero, cons_eq_cons]
state_before: α : Type u_1
β : Type ?u.26091
γ : Type ?u.26094
a b : α
m : Multiset α
⊢ {a} = b ::ₘ m ↔ a = b ∧ m = 0

tactic: simp [eq_comm]
state_before: α : Type u_1
β : Type ?u.26091
γ : Type ?u.26094
a b : α
m : Multiset α
⊢ (a = b ∧ 0 = m ∨ a ≠ b ∧ ∃ cs, 0 = b ::ₘ cs ∧ m = a ::ₘ cs) ↔ a = b ∧ m = 0
Theorem: Stream'.take_succ'
File: Mathlib/Data/Stream/Init.lean

tactic: rw [take_succ, take_succ' n, ← List.cons_append, ← take_succ, nth_tail]
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
n : ℕ
⊢ take (n + 1 + 1) s = take (n + 1) s ++ [nth s (n + 1)]
Theorem: padicValInt_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValInt_dvd_iff]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
⊢ ↑p ^ padicValInt p a ∣ a

tactic: exact Or.inr le_rfl
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
⊢ a = 0 ∨ padicValInt p a ≤ padicValInt p a
Theorem: exists_prime_addOrderOf_dvd_card
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: convert hdvd
state_before: α : Type ?u.713413
inst✝³ : Fintype α
G✝ : Type ?u.713419
inst✝² : Group G✝
n : ℕ
G : Type u_1
inst✝¹ : AddGroup G
inst✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
hdvd : p ∣ Fintype.card G
⊢ p ∣ Fintype.card (Multiplicative G)
Theorem: toIcoMod_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIcoMod_sub_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a (b - p) = toIcoMod hp a b