tasksource/leandojo huggingface dataset:
Theorem: TensorProduct.tmul_sum
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: induction' s using Finset.induction with a s has ih h
state_before: R : Type u_4
inst✝¹⁶ : CommSemiring R
R' : Type ?u.467150
inst✝¹⁵ : Monoid R'
R'' : Type ?u.467156
inst✝¹⁴ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.467168
Q : Type ?u.467171
S : Type ?u.467174
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
m : M
α : Type u_1
s : Finset α
n : α → N
⊢ m ⊗ₜ[R] ∑ a in s, n a = ∑ a in s, m ⊗ₜ[R] n a

tactic: simp
state_before: case empty
R : Type u_4
inst✝¹⁶ : CommSemiring R
R' : Type ?u.467150
inst✝¹⁵ : Monoid R'
R'' : Type ?u.467156
inst✝¹⁴ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.467168
Q : Type ?u.467171
S : Type ?u.467174
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
m : M
α : Type u_1
n : α → N
⊢ m ⊗ₜ[R] ∑ a in ∅, n a = ∑ a in ∅, m ⊗ₜ[R] n a

tactic: simp [Finset.sum_insert has, tmul_add, ih]
state_before: case insert
R : Type u_4
inst✝¹⁶ : CommSemiring R
R' : Type ?u.467150
inst✝¹⁵ : Monoid R'
R'' : Type ?u.467156
inst✝¹⁴ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.467168
Q : Type ?u.467171
S : Type ?u.467174
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
m : M
α : Type u_1
n : α → N
a : α
s : Finset α
has : ¬a ∈ s
ih : m ⊗ₜ[R] ∑ a in s, n a = ∑ a in s, m ⊗ₜ[R] n a
⊢ m ⊗ₜ[R] ∑ a in insert a s, n a = ∑ a in insert a s, m ⊗ₜ[R] n a
Theorem: Finset.sdiff_eq_self
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [Subset.antisymm_iff, disjoint_iff_inter_eq_empty]
state_before: α : Type u_1
β : Type ?u.400335
γ : Type ?u.400338
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s₁ s₂ : Finset α
⊢ s₁ \ s₂ = s₁ ↔ s₁ ∩ s₂ ⊆ ∅
Theorem: posMulMonoRev_iff_mulPosMonoRev
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simp only [PosMulMonoRev, MulPosMonoRev, mul_comm]
state_before: α : Type u_1
a b c d : α
inst✝² : CommSemigroup α
inst✝¹ : Zero α
inst✝ : Preorder α
⊢ PosMulMonoRev α ↔ MulPosMonoRev α
Theorem: injective_pow_iff_not_isOfFinOrder
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: refine' ⟨fun h => not_isOfFinOrder_of_injective_pow h, fun h n m hnm => _⟩
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝ : LeftCancelMonoid G
x : G
⊢ (Injective fun n => x ^ n) ↔ ¬IsOfFinOrder x

tactic: rwa [pow_eq_pow_iff_modEq, orderOf_eq_zero_iff.mpr h, modEq_zero_iff] at hnm
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n✝ m✝ : ℕ
inst✝ : LeftCancelMonoid G
x : G
h : ¬IsOfFinOrder x
n m : ℕ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
Theorem: Matrix.vandermonde_succ
File: Mathlib/LinearAlgebra/Vandermonde.lean

tactic: conv_lhs => rw [← Fin.cons_self_tail v, vandermonde_cons]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin (Nat.succ n) → R
⊢ vandermonde v =
    Fin.cons (fun j => v 0 ^ ↑j) fun i => Fin.cons 1 fun j => v (Fin.succ i) * vandermonde (Fin.tail v) i j
Theorem: Polynomial.roots_normalize
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [normalize_apply, mul_comm, coe_normUnit, roots_C_mul _ (normUnit (leadingCoeff p)).ne_zero]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizationMonoid R
p : R[X]
⊢ roots (↑normalize p) = roots p
Theorem: Filter.HasBasis.sup_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [(hl.sup' (hasBasis_principal t)).mem_iff, PProd.exists, exists_prop, and_true_iff,
  Unique.exists_iff]
state_before: α : Type u_1
β : Type ?u.42785
γ : Type ?u.42788
ι : Sort u_2
ι' : Sort ?u.42794
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
t u : Set α
⊢ u ∈ l ⊔ 𝓟 t ↔ ∃ i, p i ∧ s i ∪ t ⊆ u
Theorem: GeneralizedContinuedFraction.of_h_eq_floor
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: simp [of_h_eq_intFractPair_seq1_fst_b, IntFractPair.of]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
⊢ (of v).h = ↑⌊v⌋
Theorem: Complex.lim_re
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [lim_eq_lim_im_add_lim_re]
state_before: f : CauSeq ℂ ↑abs
⊢ CauSeq.lim (cauSeqRe f) = (CauSeq.lim f).re

tactic: simp [ofReal']
state_before: f : CauSeq ℂ ↑abs
⊢ CauSeq.lim (cauSeqRe f) = (↑(CauSeq.lim (cauSeqRe f)) + ↑(CauSeq.lim (cauSeqIm f)) * I).re
Theorem: Real.arctan_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: simp [arctan_eq_arcsin]
state_before: ⊢ arctan 0 = 0
Theorem: Primrec.list_ofFn
File: Mathlib/Computability/Primrec.lean

tactic: simp [List.ofFn_succ]
state_before: α : Type u_1
β : Type ?u.365224
γ : Type ?u.365227
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin (n + 1) → α → σ
hf : ∀ (i : Fin (n + 1)), Primrec (f i)
⊢ Primrec fun a => List.ofFn fun i => f i a

tactic: exact list_cons.comp (hf 0) (list_ofFn fun i => hf i.succ)
state_before: α : Type u_1
β : Type ?u.365224
γ : Type ?u.365227
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin (n + 1) → α → σ
hf : ∀ (i : Fin (n + 1)), Primrec (f i)
⊢ Primrec fun a => f 0 a :: List.ofFn fun i => f (Fin.succ i) a
Theorem: Fin.fin_one_eq_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Subsingleton.elim a 0]
state_before: n m : ℕ
a : Fin 1
⊢ a = 0
Theorem: ENNReal.tendsto_sub
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only at h
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
h : ⊤ ≠ ⊤ ∨ ⊤ ≠ ⊤
⊢ Tendsto (fun p => p.fst - p.snd) (𝓝 (⊤, ⊤)) (𝓝 (⊤ - ⊤))

tactic: rw [top_sub_coe, tendsto_nhds_top_iff_nnreal]
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
b : ℝ≥0
x✝ : ⊤ ≠ ⊤ ∨ ↑b ≠ ⊤
⊢ Tendsto (fun p => p.fst - p.snd) (𝓝 (⊤, ↑b)) (𝓝 (⊤ - ↑b))

tactic: refine fun x => ((lt_mem_nhds <| @coe_lt_top (b + 1 + x)).prod_nhds
  (ge_mem_nhds <| coe_lt_coe.2 <| lt_add_one b)).mono fun y hy => ?_
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
b : ℝ≥0
x✝ : ⊤ ≠ ⊤ ∨ ↑b ≠ ⊤
⊢ ∀ (x : ℝ≥0), ∀ᶠ (a : ℝ≥0∞ × ℝ≥0∞) in 𝓝 (⊤, ↑b), ↑x < a.fst - a.snd

tactic: rw [lt_tsub_iff_left]
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x✝¹ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
b : ℝ≥0
x✝ : ⊤ ≠ ⊤ ∨ ↑b ≠ ⊤
x : ℝ≥0
y : ℝ≥0∞ × ℝ≥0∞
hy : ↑(b + 1 + x) < y.fst ∧ y.snd ≤ ↑(b + 1)
⊢ ↑x < y.fst - y.snd

tactic: calc y.2 + x ≤ ↑(b + 1) + x := add_le_add_right hy.2 _
_ < y.1 := hy.1
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x✝¹ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
b : ℝ≥0
x✝ : ⊤ ≠ ⊤ ∨ ↑b ≠ ⊤
x : ℝ≥0
y : ℝ≥0∞ × ℝ≥0∞
hy : ↑(b + 1 + x) < y.fst ∧ y.snd ≤ ↑(b + 1)
⊢ y.snd + ↑x < y.fst

tactic: rw [sub_top]
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
x✝ : ↑a ≠ ⊤ ∨ ⊤ ≠ ⊤
⊢ Tendsto (fun p => p.fst - p.snd) (𝓝 (↑a, ⊤)) (𝓝 (↑a - ⊤))

tactic: refine (tendsto_pure.2 ?_).mono_right (pure_le_nhds _)
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
x✝ : ↑a ≠ ⊤ ∨ ⊤ ≠ ⊤
⊢ Tendsto (fun p => p.fst - p.snd) (𝓝 (↑a, ⊤)) (𝓝 0)

tactic: exact ((gt_mem_nhds <| coe_lt_coe.2 <| lt_add_one a).prod_nhds
  (lt_mem_nhds <| @coe_lt_top (a + 1))).mono fun x hx =>
    tsub_eq_zero_iff_le.2 (hx.1.trans hx.2).le
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
x✝ : ↑a ≠ ⊤ ∨ ⊤ ≠ ⊤
⊢ ∀ᶠ (x : ℝ≥0∞ × ℝ≥0∞) in 𝓝 (↑a, ⊤), x.fst - x.snd = 0

tactic: exact continuous_sub.tendsto (a, b)
state_before: α : Type ?u.83081
β : Type ?u.83084
γ : Type ?u.83087
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a b : ℝ≥0
x✝ : ↑a ≠ ⊤ ∨ ↑b ≠ ⊤
⊢ Tendsto (fun a => a.fst - a.snd) (𝓝 (a, b)) (𝓝 (a - b))
Theorem: Ordinal.opow_add
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rcases eq_or_ne a 0 with (rfl | a0)
state_before: a b c : Ordinal
⊢ a ^ (b + c) = a ^ b * a ^ c

tactic: rcases eq_or_lt_of_le (one_le_iff_ne_zero.2 a0) with (rfl | a1)
state_before: case inr
a b c : Ordinal
a0 : a ≠ 0
⊢ a ^ (b + c) = a ^ b * a ^ c

tactic: apply limitRecOn c
state_before: case inr.inr
a b c : Ordinal
a0 : a ≠ 0
a1 : 1 < a
⊢ a ^ (b + c) = a ^ b * a ^ c

tactic: rcases eq_or_ne c 0 with (rfl | c0)
state_before: case inl
b c : Ordinal
⊢ 0 ^ (b + c) = 0 ^ b * 0 ^ c

tactic: have : b + c ≠ 0 := ((Ordinal.pos_iff_ne_zero.2 c0).trans_le (le_add_left _ _)).ne'
state_before: case inl.inr
b c : Ordinal
c0 : c ≠ 0
⊢ 0 ^ (b + c) = 0 ^ b * 0 ^ c

tactic: simp only [zero_opow c0, zero_opow this, mul_zero]
state_before: case inl.inr
b c : Ordinal
c0 : c ≠ 0
this : b + c ≠ 0
⊢ 0 ^ (b + c) = 0 ^ b * 0 ^ c

tactic: simp
state_before: case inl.inl
b : Ordinal
⊢ 0 ^ (b + 0) = 0 ^ b * 0 ^ 0

tactic: simp only [one_opow, mul_one]
state_before: case inr.inl
b c : Ordinal
a0 : 1 ≠ 0
⊢ 1 ^ (b + c) = 1 ^ b * 1 ^ c

tactic: simp
state_before: case inr.inr.H₁
a b c : Ordinal
a0 : a ≠ 0
a1 : 1 < a
⊢ a ^ (b + 0) = a ^ b * a ^ 0

tactic: intro c IH
state_before: case inr.inr.H₂
a b c : Ordinal
a0 : a ≠ 0
a1 : 1 < a
⊢ ∀ (o : Ordinal), a ^ (b + o) = a ^ b * a ^ o → a ^ (b + succ o) = a ^ b * a ^ succ o

tactic: rw [add_succ, opow_succ, IH, opow_succ, mul_assoc]
state_before: case inr.inr.H₂
a b c✝ : Ordinal
a0 : a ≠ 0
a1 : 1 < a
c : Ordinal
IH : a ^ (b + c) = a ^ b * a ^ c
⊢ a ^ (b + succ c) = a ^ b * a ^ succ c

tactic: intro c l IH
state_before: case inr.inr.H₃
a b c : Ordinal
a0 : a ≠ 0
a1 : 1 < a
⊢ ∀ (o : Ordinal), IsLimit o → (∀ (o' : Ordinal), o' < o → a ^ (b + o') = a ^ b * a ^ o') → a ^ (b + o) = a ^ b * a ^ o

tactic: refine'
  eq_of_forall_ge_iff fun d =>
    (((opow_isNormal a1).trans (add_isNormal b)).limit_le l).trans _
state_before: case inr.inr.H₃
a b c✝ : Ordinal
a0 : a ≠ 0
a1 : 1 < a
c : Ordinal
l : IsLimit c
IH : ∀ (o' : Ordinal), o' < c → a ^ (b + o') = a ^ b * a ^ o'
⊢ a ^ (b + c) = a ^ b * a ^ c

tactic: dsimp only [Function.comp]
state_before: case inr.inr.H₃
a b c✝ : Ordinal
a0 : a ≠ 0
a1 : 1 < a
c : Ordinal
l : IsLimit c
IH : ∀ (o' : Ordinal), o' < c → a ^ (b + o') = a ^ b * a ^ o'
d : Ordinal
⊢ (∀ (b_1 : Ordinal), b_1 < c → ((fun x x_1 => x ^ x_1) a ∘ (fun x x_1 => x + x_1) b) b_1 ≤ d) ↔ a ^ b * a ^ c ≤ d

tactic: simp (config := { contextual := true }) only [IH]
state_before: case inr.inr.H₃
a b c✝ : Ordinal
a0 : a ≠ 0
a1 : 1 < a
c : Ordinal
l : IsLimit c
IH : ∀ (o' : Ordinal), o' < c → a ^ (b + o') = a ^ b * a ^ o'
d : Ordinal
⊢ (∀ (b_1 : Ordinal), b_1 < c → a ^ (b + b_1) ≤ d) ↔ a ^ b * a ^ c ≤ d

tactic: exact
  (((mul_isNormal <| opow_pos b (Ordinal.pos_iff_ne_zero.2 a0)).trans
          (opow_isNormal a1)).limit_le
      l).symm
state_before: case inr.inr.H₃
a b c✝ : Ordinal
a0 : a ≠ 0
a1 : 1 < a
c : Ordinal
l : IsLimit c
IH : ∀ (o' : Ordinal), o' < c → a ^ (b + o') = a ^ b * a ^ o'
d : Ordinal
⊢ (∀ (b_1 : Ordinal), b_1 < c → a ^ b * a ^ b_1 ≤ d) ↔ a ^ b * a ^ c ≤ d
Theorem: Subgroup.commProb_subgroup_le
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: rw [commProb_def, commProb_def, div_le_iff, mul_assoc, ← mul_pow, ← Nat.cast_mul,
  mul_comm H.index, H.card_mul_index, div_mul_cancel, Nat.cast_le]
state_before: M : Type ?u.20589
inst✝⁴ : Mul M
inst✝³ : Finite M
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : Group G
H : Subgroup G
⊢ commProb { x // x ∈ H } ≤ commProb G * ↑(index H) ^ 2

tactic: refine' Finite.card_le_of_injective (fun p ↦ ⟨⟨p.1.1, p.1.2⟩, Subtype.ext_iff.mp p.2⟩) _
state_before: M : Type ?u.20589
inst✝⁴ : Mul M
inst✝³ : Finite M
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : Group G
H : Subgroup G
⊢ Nat.card { p // p.fst * p.snd = p.snd * p.fst } ≤ Nat.card { p // p.fst * p.snd = p.snd * p.fst }

tactic: exact fun p q h ↦ by simpa only [Subtype.ext_iff, Prod.ext_iff] using h
state_before: M : Type ?u.20589
inst✝⁴ : Mul M
inst✝³ : Finite M
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : Group G
H : Subgroup G
⊢ Function.Injective fun p =>
    { val := (↑(↑p).fst, ↑(↑p).snd), property := (_ : ↑((↑p).fst * (↑p).snd) = ↑((↑p).snd * (↑p).fst)) }

tactic: simpa only [Subtype.ext_iff, Prod.ext_iff] using h
state_before: M : Type ?u.20589
inst✝⁴ : Mul M
inst✝³ : Finite M
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : Group G
H : Subgroup G
p q : { p // p.fst * p.snd = p.snd * p.fst }
h :
  (fun p => { val := (↑(↑p).fst, ↑(↑p).snd), property := (_ : ↑((↑p).fst * (↑p).snd) = ↑((↑p).snd * (↑p).fst)) }) p =
    (fun p => { val := (↑(↑p).fst, ↑(↑p).snd), property := (_ : ↑((↑p).fst * (↑p).snd) = ↑((↑p).snd * (↑p).fst)) }) q
⊢ p = q

tactic: exact pow_ne_zero 2 (Nat.cast_ne_zero.mpr Finite.card_pos.ne')
state_before: case h
M : Type ?u.20589
inst✝⁴ : Mul M
inst✝³ : Finite M
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : Group G
H : Subgroup G
⊢ ↑(Nat.card G) ^ 2 ≠ 0

tactic: exact pow_pos (Nat.cast_pos.mpr Finite.card_pos) 2
state_before: M : Type ?u.20589
inst✝⁴ : Mul M
inst✝³ : Finite M
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : Group G
H : Subgroup G
⊢ 0 < ↑(Nat.card { x // x ∈ H }) ^ 2
Theorem: LinearPMap.IsClosable.existsUnique
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: refine' exists_unique_of_exists_of_unique hf fun _ _ hy₁ hy₂ => eq_of_eq_graph _
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ ∃! f', Submodule.topologicalClosure (graph f) = graph f'

tactic: rw [← hy₁, ← hy₂]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
x✝¹ x✝ : E →ₗ.[R] F
hy₁ : Submodule.topologicalClosure (graph f) = graph x✝¹
hy₂ : Submodule.topologicalClosure (graph f) = graph x✝
⊢ graph x✝¹ = graph x✝
Theorem: pow_card_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [← Nat.card_eq_fintype_card, pow_card_eq_one']
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Fintype G
⊢ x ^ Fintype.card G = 1
Theorem: Finset.univ_map_embedding
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [← e.equiv_of_fintype_self_embedding_to_embedding, univ_map_equiv_to_embedding]
state_before: α✝ : Type ?u.54720
β : Type ?u.54723
γ : Type ?u.54726
α : Type u_1
inst✝ : Fintype α
e : α ↪ α
⊢ map e univ = univ
Theorem: Nat.forall_lt_succ
File: Mathlib/Data/Nat/Basic.lean

tactic: simp only [lt_succ_iff, Decidable.le_iff_eq_or_lt, forall_eq_or_imp, and_comm]
state_before: m n✝ k : ℕ
P : ℕ → Prop
n : ℕ
⊢ (∀ (m : ℕ), m < n + 1 → P m) ↔ (∀ (m : ℕ), m < n → P m) ∧ P n
Theorem: Finset.piecewise_eq_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [piecewise, hi]
state_before: α : Type u_1
β : Type ?u.296207
γ : Type ?u.296210
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
i : α
hi : i ∈ s
⊢ piecewise s f g i = f i
Theorem: SimplexCategory.image_eq
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: haveI := strongEpi_of_epi e
state_before: Δ Δ' Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ Δ'
inst✝¹ : Epi e
i : Δ' ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
⊢ image φ = Δ'

tactic: let e := image.isoStrongEpiMono e i fac
state_before: Δ Δ' Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ Δ'
inst✝¹ : Epi e
i : Δ' ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
this : StrongEpi e
⊢ image φ = Δ'

tactic: ext
state_before: Δ Δ' Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e✝ : Δ ⟶ Δ'
inst✝¹ : Epi e✝
i : Δ' ⟶ Δ''
inst✝ : Mono i
fac : e✝ ≫ i = φ
this : StrongEpi e✝
e : Δ' ≅ image φ := image.isoStrongEpiMono e✝ i fac
⊢ image φ = Δ'

tactic: exact
  le_antisymm (len_le_of_epi (inferInstance : Epi e.hom))
    (len_le_of_mono (inferInstance : Mono e.hom))
state_before: case a
Δ Δ' Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e✝ : Δ ⟶ Δ'
inst✝¹ : Epi e✝
i : Δ' ⟶ Δ''
inst✝ : Mono i
fac : e✝ ≫ i = φ
this : StrongEpi e✝
e : Δ' ≅ image φ := image.isoStrongEpiMono e✝ i fac
⊢ len (image φ) = len Δ'
Theorem: Zsqrtd.bit1_im
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [bit1]
state_before: d : ℤ
z : ℤ√d
⊢ (bit1 z).im = bit0 z.im
Theorem: Eq.subset
File: Mathlib/Data/Set/Basic.lean

tactic: rw [← h₁]
state_before: α : Type u_1
s t : Set α
h₁ : s = t
x✝ : α
h₂ : x✝ ∈ s
⊢ x✝ ∈ t

tactic: exact h₂
state_before: α : Type u_1
s t : Set α
h₁ : s = t
x✝ : α
h₂ : x✝ ∈ s
⊢ x✝ ∈ s
Theorem: Filter.map₂_pure_left
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [image2_singleton_left, image_subset_iff]
state_before: α : Type u_2
α' : Type ?u.27454
β : Type u_3
β' : Type ?u.27460
γ : Type u_1
γ' : Type ?u.27466
δ : Type ?u.27469
δ' : Type ?u.27472
ε : Type ?u.27475
ε' : Type ?u.27478
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
u : Set γ
h : u ∈ map (fun b => m a b) g
⊢ image2 m {a} ((fun b => m a b) ⁻¹' u) ⊆ u
Theorem: sameRay_of_mem_orbit
File: Mathlib/LinearAlgebra/Ray.lean

tactic: rcases h with ⟨⟨r, hr : 0 < r.1⟩, rfl : r • v₂ = v₁⟩
state_before: R : Type u_2
inst✝² : LinearOrderedCommRing R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
v₁ v₂ : M
h : v₁ ∈ MulAction.orbit { x // x ∈ Units.posSubgroup R } v₂
⊢ SameRay R v₁ v₂

tactic: exact SameRay.sameRay_pos_smul_left _ hr
state_before: case intro.mk
R : Type u_2
inst✝² : LinearOrderedCommRing R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
v₂ : M
r : Rˣ
hr : 0 < ↑r
⊢ SameRay R (r • v₂) v₂
Theorem: isLowerSet_iff_forall_lt
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [le_iff_eq_or_lt, or_imp, forall_and]
state_before: α : Type u_1
β : Type ?u.27108
γ : Type ?u.27111
ι : Sort ?u.27114
κ : ι → Sort ?u.27119
inst✝ : PartialOrder α
s : Set α
a : α
⊢ (∀ ⦃b : α⦄, b ≤ a → a ∈ s → b ∈ s) ↔ ∀ ⦃b : α⦄, b < a → a ∈ s → b ∈ s
Theorem: Subgroup.is_normal_topologicalClosure
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: apply map_mem_closure (TopologicalGroup.continuous_conj g) hn
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁷ : TopologicalSpace G✝
inst✝⁶ : Group G✝
inst✝⁵ : TopologicalGroup G✝
inst✝⁴ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
N : Subgroup G
inst✝ : Normal N
n : G
hn : n ∈ topologicalClosure N
g : G
⊢ g * n * g⁻¹ ∈ topologicalClosure N

tactic: exact fun m hm => Subgroup.Normal.conj_mem inferInstance m hm g
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁷ : TopologicalSpace G✝
inst✝⁶ : Group G✝
inst✝⁵ : TopologicalGroup G✝
inst✝⁴ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
N : Subgroup G
inst✝ : Normal N
n : G
hn : n ∈ topologicalClosure N
g : G
⊢ MapsTo (fun h => g * h * g⁻¹) ↑N ↑N
Theorem: AffineSubspace.isPreconnected_setOf_wSameSide
File: Mathlib/Analysis/Convex/Side.lean

tactic: rcases Set.eq_empty_or_nonempty (s : Set P) with (h | h)
state_before: R : Type ?u.470015
V : Type u_1
V' : Type ?u.470021
P : Type u_2
P' : Type ?u.470027
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
⊢ IsPreconnected {y | WSameSide s x y}

tactic: rw [coe_eq_bot_iff] at h
state_before: case inl
R : Type ?u.470015
V : Type u_1
V' : Type ?u.470021
P : Type u_2
P' : Type ?u.470027
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : ↑s = ∅
⊢ IsPreconnected {y | WSameSide s x y}

tactic: simp only [h, not_wSameSide_bot]
state_before: case inl
R : Type ?u.470015
V : Type u_1
V' : Type ?u.470021
P : Type u_2
P' : Type ?u.470027
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : s = ⊥
⊢ IsPreconnected {y | WSameSide s x y}

tactic: exact isPreconnected_empty
state_before: case inl
R : Type ?u.470015
V : Type u_1
V' : Type ?u.470021
P : Type u_2
P' : Type ?u.470027
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : s = ⊥
⊢ IsPreconnected {y | False}

tactic: exact (isConnected_setOf_wSameSide x h).isPreconnected
state_before: case inr
R : Type ?u.470015
V : Type u_1
V' : Type ?u.470021
P : Type u_2
P' : Type ?u.470027
inst✝³ : SeminormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
s : AffineSubspace ℝ P
x : P
h : Set.Nonempty ↑s
⊢ IsPreconnected {y | WSameSide s x y}
Theorem: Dfinsupp.support_sum
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: have :
  ∀ i₁ : ι,
    (f.sum fun (i : ι₁) (b : β₁ i) => (g i b) i₁) ≠ 0 → ∃ i : ι₁, f i ≠ 0 ∧ ¬(g i (f i)) i₁ = 0 :=
  fun i₁ h =>
  let ⟨i, hi, Ne⟩ := Finset.exists_ne_zero_of_sum_ne_zero h
  ⟨i, mem_support_iff.1 hi, Ne⟩
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
ι₁ : Type u₁
inst✝⁴ : DecidableEq ι₁
β₁ : ι₁ → Type v₁
inst✝³ : (i₁ : ι₁) → Zero (β₁ i₁)
inst✝² : (i : ι₁) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i₁ : ι₁), β₁ i₁
g : (i₁ : ι₁) → β₁ i₁ → Π₀ (i : ι), β i
⊢ support (sum f g) ⊆ Finset.biUnion (support f) fun i => support (g i (↑f i))

tactic: simpa [Finset.subset_iff, mem_support_iff, Finset.mem_biUnion, sum_apply] using this
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
ι₁ : Type u₁
inst✝⁴ : DecidableEq ι₁
β₁ : ι₁ → Type v₁
inst✝³ : (i₁ : ι₁) → Zero (β₁ i₁)
inst✝² : (i : ι₁) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i₁ : ι₁), β₁ i₁
g : (i₁ : ι₁) → β₁ i₁ → Π₀ (i : ι), β i
this : ∀ (i₁ : ι), (sum f fun i b => ↑(g i b) i₁) ≠ 0 → ∃ i, ↑f i ≠ 0 ∧ ¬↑(g i (↑f i)) i₁ = 0
⊢ support (sum f g) ⊆ Finset.biUnion (support f) fun i => support (g i (↑f i))