tasksource/leandojo huggingface dataset:
Theorem: MultilinearMap.mkPiRing_eq_iff
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simp_rw [MultilinearMap.ext_iff, mkPiRing_apply]
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
z₁ z₂ : M₂
⊢ MultilinearMap.mkPiRing R ι z₁ = MultilinearMap.mkPiRing R ι z₂ ↔ z₁ = z₂

tactic: constructor <;> intro h
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
z₁ z₂ : M₂
⊢ (∀ (x : ι → R), (∏ i : ι, x i) • z₁ = (∏ i : ι, x i) • z₂) ↔ z₁ = z₂

tactic: simpa using h fun _ => 1
state_before: case mp
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
z₁ z₂ : M₂
h : ∀ (x : ι → R), (∏ i : ι, x i) • z₁ = (∏ i : ι, x i) • z₂
⊢ z₁ = z₂

tactic: intro x
state_before: case mpr
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
z₁ z₂ : M₂
h : z₁ = z₂
⊢ ∀ (x : ι → R), (∏ i : ι, x i) • z₁ = (∏ i : ι, x i) • z₂

tactic: simp [h]
state_before: case mpr
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
z₁ z₂ : M₂
h : z₁ = z₂
x : ι → R
⊢ (∏ i : ι, x i) • z₁ = (∏ i : ι, x i) • z₂
Theorem: goldConj_mul_gold
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [mul_comm]
state_before: ⊢ ψ * φ = -1

tactic: exact gold_mul_goldConj
state_before: ⊢ φ * ψ = -1
Theorem: Turing.ToPartrec.Code.zero'_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: ⊢ eval zero' = fun v => pure (0 :: v)
Theorem: Finset.union_empty
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.148456
γ : Type ?u.148459
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x : α
⊢ x ∈ s ∨ x ∈ ∅ ↔ x ∈ s
Theorem: Sylow.exists_subgroup_card_pow_prime_le
File: Mathlib/GroupTheory/Sylow.lean

tactic: rwa [tsub_add_cancel_of_le h0m.nat_succ_le]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
_hp✝ : Fact (Nat.Prime p)
n m : ℕ
hdvd : p ^ m ∣ Fintype.card G
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
hnm✝ : n ≤ m
hnm : n < m
h0m : 0 < m
_wf : m - 1 < m
hnm1 : n ≤ m - 1
K : Subgroup G
hK : Fintype.card { x // x ∈ K } = p ^ (m - 1) ∧ H ≤ K
⊢ p ^ (m - 1 + 1) ∣ Fintype.card G

tactic: rw [hK'.1, tsub_add_cancel_of_le h0m.nat_succ_le]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
_hp✝ : Fact (Nat.Prime p)
n m : ℕ
hdvd : p ^ m ∣ Fintype.card G
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
hnm✝ : n ≤ m
hnm : n < m
h0m : 0 < m
_wf : m - 1 < m
hnm1 : n ≤ m - 1
K : Subgroup G
hK : Fintype.card { x // x ∈ K } = p ^ (m - 1) ∧ H ≤ K
hdvd' : p ^ (m - 1 + 1) ∣ Fintype.card G
K' : Subgroup G
hK' : Fintype.card { x // x ∈ K' } = p ^ (m - 1 + 1) ∧ K ≤ K'
⊢ Fintype.card { x // x ∈ K' } = p ^ m

tactic: simp [hH, hnm]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
_hp✝ : Fact (Nat.Prime p)
n m : ℕ
hdvd : p ^ m ∣ Fintype.card G
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
hnm✝ : n ≤ m
hnm : n = m
⊢ Fintype.card { x // x ∈ H } = p ^ m ∧ H ≤ H
Theorem: Associates.prod_add
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
b : FactorSet α
⊢ FactorSet.prod (⊤ + b) = FactorSet.prod ⊤ * FactorSet.prod b

tactic: simp
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
a : FactorSet α
⊢ FactorSet.prod (a + ⊤) = FactorSet.prod a * FactorSet.prod ⊤

tactic: rw [← FactorSet.coe_add, prod_coe, prod_coe, prod_coe, Multiset.map_add, Multiset.prod_add]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
a b : Multiset { a // Irreducible a }
⊢ FactorSet.prod (↑a + ↑b) = FactorSet.prod ↑a * FactorSet.prod ↑b
Theorem: DiscreteValuationRing.associated_of_irreducible
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: rw [irreducible_iff_uniformizer] at ha hb
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : Irreducible a
hb : Irreducible b
⊢ Associated a b

tactic: rw [← span_singleton_eq_span_singleton, ← ha, hb]
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha✝ : Irreducible a
ha : maximalIdeal R = span {a}
hb✝ : Irreducible b
hb : maximalIdeal R = span {b}
⊢ Associated a b
Theorem: Associated.of_mul_left
File: Mathlib/Algebra/Associated.lean

tactic: rw [← hv, mul_assoc c (v : α) d, mul_left_comm c, ← hu]
state_before: α : Type u_1
β : Type ?u.226369
γ : Type ?u.226372
δ : Type ?u.226375
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ a * (b * ↑(u * v)) = a * d

tactic: simp [hv.symm, mul_assoc, mul_comm, mul_left_comm]
state_before: α : Type u_1
β : Type ?u.226369
γ : Type ?u.226372
δ : Type ?u.226375
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ c * ↑v * (b * ↑(u * v)) = ↑v * (a * b * ↑u)
Theorem: BoxIntegral.IntegrationParams.henstock_le_riemann
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: trivial
state_before: ι : Type ?u.19641
inst✝ : Fintype ι
I J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I
l l₁ l₂ : IntegrationParams
⊢ Henstock ≤ Riemann
Theorem: Stream'.WSeq.tail_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [tail]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ tail (think s) = think (tail s)
Theorem: Finset.powerset_eq_singleton_empty
File: Mathlib/Data/Finset/Powerset.lean

tactic: rw [← powerset_empty, powerset_inj]
state_before: α : Type u_1
s t : Finset α
⊢ powerset s = {∅} ↔ s = ∅
Theorem: Set.singleton_inter_nonempty
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [Set.Nonempty, mem_inter_iff, mem_singleton_iff, exists_eq_left]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ Set.Nonempty ({a} ∩ s) ↔ a ∈ s
Theorem: List.tail_eq_tail?
File: Std/Data/List/Lemmas.lean

tactic: simp [tail_eq_tailD]
state_before: α : Type u_1
l : List α
⊢ tail l = Option.getD (tail? l) []
Theorem: Std.AssocList.find?_eq
File: Std/Data/AssocList.lean

tactic: simp [find?_eq_findEntry?]
state_before: α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
l : AssocList α β
⊢ find? a l = Option.map (fun x => x.snd) (List.find? (fun x => x.fst == a) (toList l))
Theorem: Int.floor_sub_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [Int.cast_neg, sub_eq_add_neg]
state_before: F : Type ?u.135550
α : Type u_1
β : Type ?u.135556
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
z : ℤ
⊢ ⌊a - ↑z⌋ = ⌊a + ↑(-z)⌋
Theorem: Filter.HasBasis.eventually_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simpa using hl.mem_iff
state_before: α : Type u_1
β : Type ?u.17529
γ : Type ?u.17532
ι : Sort u_2
ι' : Sort ?u.17538
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
q : α → Prop
⊢ (∀ᶠ (x : α) in l, q x) ↔ ∃ i, p i ∧ ∀ ⦃x : α⦄, x ∈ s i → q x
Theorem: padicNorm.sum_lt'
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: obtain rfl | hs := Finset.eq_empty_or_nonempty s
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
hF : ∀ (i : α), i ∈ s → padicNorm p (F i) < t
ht : 0 < t
⊢ padicNorm p (∑ i in s, F i) < t

tactic: simp [ht]
state_before: case inl
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
ht : 0 < t
hF : ∀ (i : α), i ∈ ∅ → padicNorm p (F i) < t
⊢ padicNorm p (∑ i in ∅, F i) < t

tactic: exact sum_lt hs hF
state_before: case inr
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
hF : ∀ (i : α), i ∈ s → padicNorm p (F i) < t
ht : 0 < t
hs : Finset.Nonempty s
⊢ padicNorm p (∑ i in s, F i) < t
Theorem: IntervalIntegrable.comp_mul_left_iff
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa [hc] using h.comp_mul_left c⁻¹
state_before: ι : Type ?u.7085574
𝕜 : Type ?u.7085577
E : Type u_1
F : Type ?u.7085583
A : Type ?u.7085586
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f g : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
c : ℝ
hc : c ≠ 0
h : IntervalIntegrable (fun x => f (c * x)) volume (a / c) (b / c)
⊢ IntervalIntegrable f volume a b
Theorem: Cardinal.deriv_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simpa using Cardinal.one_lt_aleph0.trans (lt_of_le_of_ne hc.1 hc'.symm)
state_before: α : Type ?u.168645
r : α → α → Prop
f : Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal), i < ord c → f i < ord c
a : Ordinal
⊢ lift (#Unit) < c
Theorem: List.rotate'_length
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate'_eq_drop_append_take le_rfl]
state_before: α : Type u
l : List α
⊢ rotate' l (length l) = l

tactic: simp
state_before: α : Type u
l : List α
⊢ drop (length l) l ++ take (length l) l = l
Theorem: Matrix.rank_mul_le_right
File: Mathlib/Data/Matrix/Rank.lean

tactic: rw [rank, rank, mulVecLin_mul]
state_before: l : Type u_2
m : Type u_3
n : Type u_4
o : Type ?u.37975
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix l m R
B : Matrix m n R
⊢ rank (A ⬝ B) ≤ rank B

tactic: exact
  finrank_le_finrank_of_rank_le_rank (LinearMap.lift_rank_comp_le_right _ _) (rank_lt_aleph0 _ _)
state_before: l : Type u_2
m : Type u_3
n : Type u_4
o : Type ?u.37975
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix l m R
B : Matrix m n R
⊢ finrank R { x // x ∈ LinearMap.range (LinearMap.comp (mulVecLin A) (mulVecLin B)) } ≤
    finrank R { x // x ∈ LinearMap.range (mulVecLin B) }
Theorem: Primrec₂.unpaired
File: Mathlib/Computability/Primrec.lean

tactic: simpa using h.comp natPair
state_before: α : Type u_1
β : Type ?u.66894
σ : Type ?u.66897
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : ℕ → ℕ → α
h : Primrec (Nat.unpaired f)
⊢ Primrec₂ f
Theorem: numDerangements_succ
File: Mathlib/Combinatorics/Derangements/Finite.lean

tactic: induction' n with n hn
state_before: α : Type ?u.11655
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
⊢ ↑(numDerangements (n + 1)) = (↑n + 1) * ↑(numDerangements n) - (-1) ^ n

tactic: rfl
state_before: case zero
α : Type ?u.11655
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ ↑(numDerangements (Nat.zero + 1)) = (↑Nat.zero + 1) * ↑(numDerangements Nat.zero) - (-1) ^ Nat.zero

tactic: simp only [numDerangements_add_two, hn, pow_succ, Int.ofNat_mul, Int.ofNat_add, Int.ofNat_succ]
state_before: case succ
α : Type ?u.11655
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hn : ↑(numDerangements (n + 1)) = (↑n + 1) * ↑(numDerangements n) - (-1) ^ n
⊢ ↑(numDerangements (Nat.succ n + 1)) = (↑(Nat.succ n) + 1) * ↑(numDerangements (Nat.succ n)) - (-1) ^ Nat.succ n

tactic: ring
state_before: case succ
α : Type ?u.11655
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
hn : ↑(numDerangements (n + 1)) = (↑n + 1) * ↑(numDerangements n) - (-1) ^ n
⊢ (↑n + 1) * (↑(numDerangements n) + ((↑n + 1) * ↑(numDerangements n) - (-1) ^ n)) =
    (↑n + 1 + 1) * ((↑n + 1) * ↑(numDerangements n) - (-1) ^ n) - -1 * (-1) ^ n
Theorem: UniformSpace.hasBasis_nhds
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [UniformSpace.mem_nhds_iff_symm, and_assoc]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.60670
inst✝ : UniformSpace α
x : α
t : Set α
⊢ t ∈ 𝓝 x ↔ ∃ i, (i ∈ 𝓤 α ∧ SymmetricRel i) ∧ ball x i ⊆ t
Theorem: Equiv.Perm.sumCongr_refl_swap
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext x
state_before: α✝ : Sort ?u.121266
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
⊢ sumCongr (Equiv.refl α) (swap i j) = swap (Sum.inr i) (Sum.inr j)

tactic: cases x
state_before: case H
α✝ : Sort ?u.121266
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
x : α ⊕ β
⊢ ↑(sumCongr (Equiv.refl α) (swap i j)) x = ↑(swap (Sum.inr i) (Sum.inr j)) x

tactic: simp [Sum.map, swap_apply_of_ne_of_ne]
state_before: case H.inl
α✝ : Sort ?u.121266
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
val✝ : α
⊢ ↑(sumCongr (Equiv.refl α) (swap i j)) (Sum.inl val✝) = ↑(swap (Sum.inr i) (Sum.inr j)) (Sum.inl val✝)

tactic: simp only [Equiv.sumCongr_apply, Sum.map, coe_refl, comp.right_id, Sum.elim_inr, comp_apply,
  swap_apply_def, Sum.inr.injEq]
state_before: case H.inr
α✝ : Sort ?u.121266
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : β
⊢ ↑(sumCongr (Equiv.refl α) (swap i j)) (Sum.inr val✝) = ↑(swap (Sum.inr i) (Sum.inr j)) (Sum.inr val✝)

tactic: split_ifs <;> rfl
state_before: case H.inr
α✝ : Sort ?u.121266
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : β
⊢ Sum.inr (if val✝ = i then j else if val✝ = j then i else val✝) =
    if val✝ = i then Sum.inr j else if val✝ = j then Sum.inr i else Sum.inr val✝
Theorem: Asymptotics.isTheta_inv
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simpa only [inv_inv] using h.inv
state_before: α : Type u_1
β : Type ?u.43769
E : Type ?u.43772
F : Type ?u.43775
G : Type ?u.43778
E' : Type ?u.43781
F' : Type ?u.43784
G' : Type ?u.43787
E'' : Type ?u.43790
F'' : Type ?u.43793
G'' : Type ?u.43796
R : Type ?u.43799
R' : Type ?u.43802
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
f : α → 𝕜
g : α → 𝕜'
h : (fun x => (f x)⁻¹) =Θ[l] fun x => (g x)⁻¹
⊢ f =Θ[l] g
Theorem: YoungDiagram.colLen_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp [rowLen, colLen]
state_before: μ : YoungDiagram
j : ℕ
⊢ colLen (transpose μ) j = rowLen μ j
Theorem: le_map_add_map_div
File: Mathlib/Algebra/Order/Hom/Basic.lean

tactic: simpa only [add_comm, div_mul_cancel'] using map_mul_le_add f (a / b) b
state_before: ι : Type ?u.7573
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.7585
δ : Type ?u.7588
inst✝³ : Group α
inst✝² : AddCommSemigroup β
inst✝¹ : LE β
inst✝ : MulLEAddHomClass F α β
f : F
a b : α
⊢ ↑f a ≤ ↑f b + ↑f (a / b)
Theorem: Fin.mul_one
File: Mathlib/Data/Fin/Basic.lean

tactic: cases' n with n
state_before: n m : ℕ
inst✝ : NeZero n
k : Fin n
⊢ k * 1 = k

tactic: cases n
state_before: case succ
m n : ℕ
inst✝ : NeZero (Nat.succ n)
k : Fin (Nat.succ n)
⊢ k * 1 = k

tactic: simp [eq_iff_veq, mul_def, mod_eq_of_lt (is_lt k)]
state_before: case succ.succ
m n✝ : ℕ
inst✝ : NeZero (Nat.succ (Nat.succ n✝))
k : Fin (Nat.succ (Nat.succ n✝))
⊢ k * 1 = k

tactic: simp
state_before: case zero
m : ℕ
inst✝ : NeZero zero
k : Fin zero
⊢ k * 1 = k

tactic: simp [fin_one_eq_zero]
state_before: case succ.zero
m : ℕ
inst✝ : NeZero (Nat.succ zero)
k : Fin (Nat.succ zero)
⊢ k * 1 = k
Theorem: toIcoMod_neg'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [neg_neg] using toIcoMod_neg hp (-a) (-b)
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (-a) b = p - toIocMod hp a (-b)
Theorem: Complex.exp_log
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [log, exp_add_mul_I, ← ofReal_sin, sin_arg, ← ofReal_cos, cos_arg hx, ← ofReal_exp,
  Real.exp_log (abs.pos hx), mul_add, ofReal_div, ofReal_div,
  mul_div_cancel' _ (ofReal_ne_zero.2 <| abs.ne_zero hx), ← mul_assoc,
  mul_div_cancel' _ (ofReal_ne_zero.2 <| abs.ne_zero hx), re_add_im]
state_before: x : ℂ
hx : x ≠ 0
⊢ exp (log x) = x
Theorem: Summable.hasSum_iff_tendsto_nat
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: refine' ⟨fun h => h.tendsto_sum_nat, fun h => _⟩
state_before: α : Type u_1
β : Type ?u.238111
γ : Type ?u.238114
δ : Type ?u.238117
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s : Finset β
inst✝ : T2Space α
f : ℕ → α
a : α
hf : Summable f
⊢ HasSum f a ↔ Tendsto (fun n => ∑ i in range n, f i) atTop (𝓝 a)

tactic: rw [tendsto_nhds_unique h hf.hasSum.tendsto_sum_nat]
state_before: α : Type u_1
β : Type ?u.238111
γ : Type ?u.238114
δ : Type ?u.238117
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s : Finset β
inst✝ : T2Space α
f : ℕ → α
a : α
hf : Summable f
h : Tendsto (fun n => ∑ i in range n, f i) atTop (𝓝 a)
⊢ HasSum f a

tactic: exact hf.hasSum
state_before: α : Type u_1
β : Type ?u.238111
γ : Type ?u.238114
δ : Type ?u.238117
inst✝² : AddCommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s : Finset β
inst✝ : T2Space α
f : ℕ → α
a : α
hf : Summable f
h : Tendsto (fun n => ∑ i in range n, f i) atTop (𝓝 a)
⊢ HasSum f (∑' (b : ℕ), f b)
Theorem: Ordinal.isOpen_singleton_iff
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: refine' ⟨fun h ⟨h₀, hsucc⟩ => _, fun ha => _⟩
state_before: s : Set Ordinal
a : Ordinal
⊢ IsOpen {a} ↔ ¬IsLimit a

tactic: obtain ⟨b, c, hbc, hbc'⟩ :=
  (mem_nhds_iff_exists_Ioo_subset' ⟨0, Ordinal.pos_iff_ne_zero.2 h₀⟩ ⟨_, lt_succ a⟩).1
    (h.mem_nhds rfl)
state_before: case refine'_1
s : Set Ordinal
a : Ordinal
h : IsOpen {a}
x✝ : IsLimit a
h₀ : a ≠ 0
hsucc : ∀ (a_1 : Ordinal), a_1 < a → succ a_1 < a
⊢ False

tactic: have hba := hsucc b hbc.1
state_before: case refine'_1.intro.intro.intro
s : Set Ordinal
a : Ordinal
h : IsOpen {a}
x✝ : IsLimit a
h₀ : a ≠ 0
hsucc : ∀ (a_1 : Ordinal), a_1 < a → succ a_1 < a
b c : Ordinal
hbc : a ∈ Set.Ioo b c
hbc' : Set.Ioo b c ⊆ {a}
⊢ False

tactic: exact hba.ne (hbc' ⟨lt_succ b, hba.trans hbc.2⟩)
state_before: case refine'_1.intro.intro.intro
s : Set Ordinal
a : Ordinal
h : IsOpen {a}
x✝ : IsLimit a
h₀ : a ≠ 0
hsucc : ∀ (a_1 : Ordinal), a_1 < a → succ a_1 < a
b c : Ordinal
hbc : a ∈ Set.Ioo b c
hbc' : Set.Ioo b c ⊆ {a}
hba : succ b < a
⊢ False

tactic: rcases zero_or_succ_or_limit a with (rfl | ⟨b, rfl⟩ | ha')
state_before: case refine'_2
s : Set Ordinal
a : Ordinal
ha : ¬IsLimit a
⊢ IsOpen {a}

tactic: rw [← bot_eq_zero, ← Set.Iic_bot, ← Iio_succ]
state_before: case refine'_2.inl
s : Set Ordinal
ha : ¬IsLimit 0
⊢ IsOpen {0}

tactic: exact isOpen_Iio
state_before: case refine'_2.inl
s : Set Ordinal
ha : ¬IsLimit 0
⊢ IsOpen (Set.Iio (succ ⊥))

tactic: rw [← Set.Icc_self, Icc_succ_left, ← Ioo_succ_right]
state_before: case refine'_2.inr.inl.intro
s : Set Ordinal
b : Ordinal
ha : ¬IsLimit (succ b)
⊢ IsOpen {succ b}

tactic: exact isOpen_Ioo
state_before: case refine'_2.inr.inl.intro
s : Set Ordinal
b : Ordinal
ha : ¬IsLimit (succ b)
⊢ IsOpen (Set.Ioo b (succ (succ b)))

tactic: exact (ha ha').elim
state_before: case refine'_2.inr.inr
s : Set Ordinal
a : Ordinal
ha : ¬IsLimit a
ha' : IsLimit a
⊢ IsOpen {a}
Theorem: Finset.sum_powerset_neg_one_pow_card_of_nonempty
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: classical
  rw [sum_powerset_neg_one_pow_card, if_neg]
  rw [← Ne.def, ← nonempty_iff_ne_empty]
  apply h0
state_before: R : Type ?u.210079
α : Type u_1
x : Finset α
h0 : Finset.Nonempty x
⊢ ∑ m in powerset x, (-1) ^ card m = 0

tactic: rw [sum_powerset_neg_one_pow_card, if_neg]
state_before: R : Type ?u.210079
α : Type u_1
x : Finset α
h0 : Finset.Nonempty x
⊢ ∑ m in powerset x, (-1) ^ card m = 0

tactic: rw [← Ne.def, ← nonempty_iff_ne_empty]
state_before: case hnc
R : Type ?u.210079
α : Type u_1
x : Finset α
h0 : Finset.Nonempty x
⊢ ¬x = ∅

tactic: apply h0
state_before: case hnc
R : Type ?u.210079
α : Type u_1
x : Finset α
h0 : Finset.Nonempty x
⊢ Finset.Nonempty x
Theorem: Submodule.map₂_iSup_left
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: suffices map₂ f (⨆ i, span R (s i : Set M)) (span R t) = ⨆ i, map₂ f (span R (s i)) (span R t) by
  simpa only [span_eq] using this
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : ι → Submodule R M
t : Submodule R N
⊢ map₂ f (⨆ (i : ι), s i) t = ⨆ (i : ι), map₂ f (s i) t

tactic: simp_rw [map₂_span_span, ← span_iUnion, map₂_span_span, Set.image2_iUnion_left]
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : ι → Submodule R M
t : Submodule R N
⊢ map₂ f (⨆ (i : ι), span R ↑(s i)) (span R ↑t) = ⨆ (i : ι), map₂ f (span R ↑(s i)) (span R ↑t)

tactic: simpa only [span_eq] using this
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : ι → Submodule R M
t : Submodule R N
this : map₂ f (⨆ (i : ι), span R ↑(s i)) (span R ↑t) = ⨆ (i : ι), map₂ f (span R ↑(s i)) (span R ↑t)
⊢ map₂ f (⨆ (i : ι), s i) t = ⨆ (i : ι), map₂ f (s i) t
Theorem: PartENat.coe_le_coe
File: Mathlib/Data/Nat/PartENat.lean

tactic: exact ⟨fun ⟨_, h⟩ => h trivial, fun h => ⟨fun _ => trivial, fun _ => h⟩⟩
state_before: x y : ℕ
⊢ ↑x ≤ ↑y ↔ x ≤ y
Theorem: IsSelfAdjoint.bit0
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_bit0, hx.star_eq]
state_before: R : Type u_1
A : Type ?u.7666
inst✝¹ : AddMonoid R
inst✝ : StarAddMonoid R
x : R
hx : IsSelfAdjoint x
⊢ IsSelfAdjoint (_root_.bit0 x)
Theorem: Multiset.lcm_ndunion
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: rw [← lcm_dedup, dedup_ext.2, lcm_dedup, lcm_add]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ lcm (ndunion s₁ s₂) = GCDMonoid.lcm (lcm s₁) (lcm s₂)

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ ndunion s₁ s₂ ↔ a ∈ s₁ + s₂