tasksource/leandojo huggingface dataset:
Theorem: LinearMap.sum_repr_mul_repr_mul
File: Mathlib/LinearAlgebra/Basis/Bilinear.lean

tactic: conv_rhs => rw [← b₁'.total_repr x, ← b₂'.total_repr y]
state_before: ι₁ : Type u_5
ι₂ : Type u_6
R : Type u_1
R₂ : Type ?u.52670
S : Type ?u.52673
S₂ : Type ?u.52676
M : Type ?u.52679
N : Type ?u.52682
P : Type ?u.52685
Mₗ : Type u_2
Nₗ : Type u_4
Pₗ : Type u_3
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : CommSemiring S
inst✝¹⁵ : CommSemiring R₂
inst✝¹⁴ : CommSemiring S₂
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Mₗ
inst✝⁹ : AddCommMonoid Nₗ
inst✝⁸ : AddCommMonoid Pₗ
inst✝⁷ : Module R M
inst✝⁶ : Module S N
inst✝⁵ : Module R₂ P
inst✝⁴ : Module S₂ P
inst✝³ : Module R Mₗ
inst✝² : Module R Nₗ
inst✝¹ : Module R Pₗ
inst✝ : SMulCommClass S₂ R₂ P
ρ₁₂ : R →+* R₂
σ₁₂ : S →+* S₂
b₁ : Basis ι₁ R M
b₂ : Basis ι₂ S N
b₁' : Basis ι₁ R Mₗ
b₂' : Basis ι₂ R Nₗ
B : Mₗ →ₗ[R] Nₗ →ₗ[R] Pₗ
x : Mₗ
y : Nₗ
⊢ (Finsupp.sum (↑b₁'.repr x) fun i xi => Finsupp.sum (↑b₂'.repr y) fun j yj => xi • yj • ↑(↑B (↑b₁' i)) (↑b₂' j)) =
    ↑(↑B x) y

tactic: simp_rw [Finsupp.total_apply, Finsupp.sum, map_sum₂, map_sum, LinearMap.map_smul₂,
  LinearMap.map_smul]
state_before: ι₁ : Type u_5
ι₂ : Type u_6
R : Type u_1
R₂ : Type ?u.52670
S : Type ?u.52673
S₂ : Type ?u.52676
M : Type ?u.52679
N : Type ?u.52682
P : Type ?u.52685
Mₗ : Type u_2
Nₗ : Type u_4
Pₗ : Type u_3
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : CommSemiring S
inst✝¹⁵ : CommSemiring R₂
inst✝¹⁴ : CommSemiring S₂
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Mₗ
inst✝⁹ : AddCommMonoid Nₗ
inst✝⁸ : AddCommMonoid Pₗ
inst✝⁷ : Module R M
inst✝⁶ : Module S N
inst✝⁵ : Module R₂ P
inst✝⁴ : Module S₂ P
inst✝³ : Module R Mₗ
inst✝² : Module R Nₗ
inst✝¹ : Module R Pₗ
inst✝ : SMulCommClass S₂ R₂ P
ρ₁₂ : R →+* R₂
σ₁₂ : S →+* S₂
b₁ : Basis ι₁ R M
b₂ : Basis ι₂ S N
b₁' : Basis ι₁ R Mₗ
b₂' : Basis ι₂ R Nₗ
B : Mₗ →ₗ[R] Nₗ →ₗ[R] Pₗ
x : Mₗ
y : Nₗ
⊢ (Finsupp.sum (↑b₁'.repr x) fun i xi => Finsupp.sum (↑b₂'.repr y) fun j yj => xi • yj • ↑(↑B (↑b₁' i)) (↑b₂' j)) =
    ↑(↑B (↑(Finsupp.total ι₁ Mₗ R ↑b₁') (↑b₁'.repr x))) (↑(Finsupp.total ι₂ Nₗ R ↑b₂') (↑b₂'.repr y))
Theorem: Fin.coe_cycleRange_of_le
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: rw [cycleRange_of_le h]
state_before: n : ℕ
i j : Fin (Nat.succ n)
h : j ≤ i
⊢ ↑(↑(cycleRange i) j) = if j = i then 0 else ↑j + 1

tactic: split_ifs with h'
state_before: n : ℕ
i j : Fin (Nat.succ n)
h : j ≤ i
⊢ ↑(if j = i then 0 else j + 1) = if j = i then 0 else ↑j + 1

tactic: exact
  val_add_one_of_lt
    (calc
      (j : ℕ) < i := Fin.lt_iff_val_lt_val.mp (lt_of_le_of_ne h h')
      _ ≤ n := Nat.lt_succ_iff.mp i.2)
state_before: case inr
n : ℕ
i j : Fin (Nat.succ n)
h : j ≤ i
h' : ¬j = i
⊢ ↑(j + 1) = ↑j + 1

tactic: rfl
state_before: case inl
n : ℕ
i j : Fin (Nat.succ n)
h : j ≤ i
h' : j = i
⊢ ↑0 = 0
Theorem: Real.pi_gt_314
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: pi_lower_bound [99 / 70, 874 / 473, 1940 / 989, 1447 / 727]
state_before: ⊢ 3.14 < π
Theorem: Set.Subsingleton.maximals_eq
File: Mathlib/Order/Minimal.lean

tactic: rcases h.eq_empty_or_singleton with (rfl | ⟨x, rfl⟩)
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
h : Set.Subsingleton s
⊢ maximals r s = s

tactic: exacts [minimals_empty _, maximals_singleton _ _]
state_before: case inl
α : Type u_1
r r₁ r₂ : α → α → Prop
t : Set α
a b : α
h : Set.Subsingleton ∅
⊢ maximals r ∅ = ∅

case inr.intro
α : Type u_1
r r₁ r₂ : α → α → Prop
t : Set α
a b x : α
h : Set.Subsingleton {x}
⊢ maximals r {x} = {x}
Theorem: IsCoprime.neg_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: obtain ⟨a, b, h⟩ := h
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
⊢ IsCoprime (-x) y

tactic: use -a, b
state_before: case intro.intro
R : Type u
inst✝ : CommRing R
x y a b : R
h : a * x + b * y = 1
⊢ IsCoprime (-x) y

tactic: rwa [neg_mul_neg]
state_before: case intro.intro
R : Type u
inst✝ : CommRing R
x y a b : R
h : a * x + b * y = 1
⊢ -a * -x + b * y = 1
Theorem: Equiv.Perm.eq_of_prodExtendRight_ne
File: Mathlib/Logic/Equiv/Basic.lean

tactic: contrapose! h
state_before: α₁ : Type u_2
β₁ : Type u_1
inst✝ : DecidableEq α₁
a✝ : α₁
e✝ e : Perm β₁
a a' : α₁
b : β₁
h : ↑(prodExtendRight a e) (a', b) ≠ (a', b)
⊢ a' = a

tactic: exact prodExtendRight_apply_ne _ h _
state_before: α₁ : Type u_2
β₁ : Type u_1
inst✝ : DecidableEq α₁
a✝ : α₁
e✝ e : Perm β₁
a a' : α₁
b : β₁
h : a' ≠ a
⊢ ↑(prodExtendRight a e) (a', b) = (a', b)
Theorem: SimpleGraph.Walk.transfer_eq_map_of_le
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
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
H : SimpleGraph V
hp : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H
GH : G ≤ H
⊢ Walk.transfer p H hp = Walk.map (Hom.mapSpanningSubgraphs GH) p
Theorem: QuotientGroup.congr_refl
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: ext ⟨x⟩
state_before: G : Type u
inst✝³ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝² : Group H
G' : Subgroup G
H' : Subgroup H
inst✝¹ : Subgroup.Normal G'
inst✝ : Subgroup.Normal H'
he : optParam (Subgroup.map (↑(MulEquiv.refl G)) G' = G') (_ : Subgroup.map (MonoidHom.id G) G' = G')
⊢ congr G' G' (MulEquiv.refl G) he = MulEquiv.refl (G ⧸ G')

tactic: rfl
state_before: case h.mk
G : Type u
inst✝³ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝² : Group H
G' : Subgroup G
H' : Subgroup H
inst✝¹ : Subgroup.Normal G'
inst✝ : Subgroup.Normal H'
he : optParam (Subgroup.map (↑(MulEquiv.refl G)) G' = G') (_ : Subgroup.map (MonoidHom.id G) G' = G')
x✝ : G ⧸ G'
x : G
⊢ ↑(congr G' G' (MulEquiv.refl G) he) (Quot.mk Setoid.r x) = ↑(MulEquiv.refl (G ⧸ G')) (Quot.mk Setoid.r x)
Theorem: Std.RBNode.All.del
File: Std/Data/RBMap/WF.lean

tactic: unfold del
state_before: α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
⊢ All p (del cut (node c✝ a✝² a✝¹ a✝))

tactic: split
state_before: α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
⊢ All p
    (match cut a✝¹ with
    | Ordering.lt =>
      match isBlack a✝² with
      | black => balLeft (del cut a✝²) a✝¹ a✝
      | red => node red (del cut a✝²) a✝¹ a✝
    | Ordering.gt =>
      match isBlack a✝ with
      | black => balRight a✝² a✝¹ (del cut a✝)
      | red => node red a✝² a✝¹ (del cut a✝)
    | Ordering.eq => append a✝² a✝)

tactic: split
state_before: case h_1
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝ : Ordering
heq✝ : cut a✝¹ = Ordering.lt
⊢ All p
    (match isBlack a✝² with
    | black => balLeft (del cut a✝²) a✝¹ a✝
    | red => node red (del cut a✝²) a✝¹ a✝)

tactic: exact ha.del.balLeft hy hb
state_before: case h_1.h_1
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝¹ : Ordering
heq✝¹ : cut a✝¹ = Ordering.lt
x✝ : RBColor
heq✝ : isBlack a✝² = black
⊢ All p (balLeft (del cut a✝²) a✝¹ a✝)

tactic: exact ⟨hy, ha.del, hb⟩
state_before: case h_1.h_2
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝¹ : Ordering
heq✝¹ : cut a✝¹ = Ordering.lt
x✝ : RBColor
heq✝ : isBlack a✝² = red
⊢ All p (node red (del cut a✝²) a✝¹ a✝)

tactic: split
state_before: case h_2
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝ : Ordering
heq✝ : cut a✝¹ = Ordering.gt
⊢ All p
    (match isBlack a✝ with
    | black => balRight a✝² a✝¹ (del cut a✝)
    | red => node red a✝² a✝¹ (del cut a✝))

tactic: exact ha.balRight hy hb.del
state_before: case h_2.h_1
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝¹ : Ordering
heq✝¹ : cut a✝¹ = Ordering.gt
x✝ : RBColor
heq✝ : isBlack a✝ = black
⊢ All p (balRight a✝² a✝¹ (del cut a✝))

tactic: exact ⟨hy, ha, hb.del⟩
state_before: case h_2.h_2
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝¹ : Ordering
heq✝¹ : cut a✝¹ = Ordering.gt
x✝ : RBColor
heq✝ : isBlack a✝ = red
⊢ All p (node red a✝² a✝¹ (del cut a✝))

tactic: exact ha.append hb
state_before: case h_3
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝ : Ordering
heq✝ : cut a✝¹ = Ordering.eq
⊢ All p (append a✝² a✝)
Theorem: concaveOn_of_slope_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

tactic: rw [← neg_convexOn_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ ConcaveOn 𝕜 s f

tactic: refine' convexOn_of_slope_mono_adjacent hs fun hx hz hxy hyz => _
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ ConvexOn 𝕜 s (-f)

tactic: rw [← neg_le_neg_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ ((-f) y✝ - (-f) x✝) / (y✝ - x✝) ≤ ((-f) z✝ - (-f) y✝) / (z✝ - y✝)

tactic: simp_rw [← neg_div, neg_sub, Pi.neg_apply, neg_sub_neg]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ -(((-f) z✝ - (-f) y✝) / (z✝ - y✝)) ≤ -(((-f) y✝ - (-f) x✝) / (y✝ - x✝))

tactic: exact hf hx hz hxy hyz
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ (f z✝ - f y✝) / (z✝ - y✝) ≤ (f y✝ - f x✝) / (y✝ - x✝)
Theorem: CompositionSeries.length_pos_of_bot_eq_bot_of_top_eq_top_of_length_pos
File: Mathlib/Order/JordanHolder.lean

tactic: simp only [pos_iff_ne_zero, Ne.def, not_iff_not, Classical.not_not]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : bot s₁ = bot s₂
ht : top s₁ = top s₂
⊢ ¬0 < s₂.length → ¬0 < s₁.length

tactic: exact length_eq_zero_of_bot_eq_bot_of_top_eq_top_of_length_eq_zero hb.symm ht.symm
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : bot s₁ = bot s₂
ht : top s₁ = top s₂
⊢ s₂.length = 0 → s₁.length = 0
Theorem: Prod.Lex.toLex_mono
File: Mathlib/Data/Prod/Lex.lean

tactic: rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⟨ha, hb⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.18624
inst✝¹ : PartialOrder α
inst✝ : Preorder β
⊢ Monotone ↑toLex

tactic: obtain rfl | ha : a₁ = a₂ ∨ _ := ha.eq_or_lt
state_before: case mk.mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.18624
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha : (a₁, b₁).fst ≤ (a₂, b₂).fst
hb : (a₁, b₁).snd ≤ (a₂, b₂).snd
⊢ ↑toLex (a₁, b₁) ≤ ↑toLex (a₂, b₂)

tactic: exact right _ hb
state_before: case mk.mk.intro.inl
α : Type u_1
β : Type u_2
γ : Type ?u.18624
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ b₂ : β
ha : (a₁, b₁).fst ≤ (a₁, b₂).fst
hb : (a₁, b₁).snd ≤ (a₁, b₂).snd
⊢ ↑toLex (a₁, b₁) ≤ ↑toLex (a₁, b₂)

tactic: exact left _ _ ha
state_before: case mk.mk.intro.inr
α : Type u_1
β : Type u_2
γ : Type ?u.18624
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha✝ : (a₁, b₁).fst ≤ (a₂, b₂).fst
hb : (a₁, b₁).snd ≤ (a₂, b₂).snd
ha : (a₁, b₁).fst < (a₂, b₂).fst
⊢ ↑toLex (a₁, b₁) ≤ ↑toLex (a₂, b₂)
Theorem: Array.data_pop
File: Std/Data/Array/Lemmas.lean

tactic: simp [pop]
state_before: α : Type u_1
a : Array α
⊢ (pop a).data = List.dropLast a.data
Theorem: SameRay.norm_smul_eq
File: Mathlib/Analysis/NormedSpace/Ray.lean

tactic: rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.9880
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : E
h : SameRay ℝ x y
⊢ ‖x‖ • y = ‖y‖ • x

tactic: simp only [norm_smul_of_nonneg, *, mul_smul]
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.9880
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u‖ • b • u = ‖b • u‖ • a • u

tactic: rw [smul_comm, smul_comm b, smul_comm a b u]
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.9880
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ a • ‖u‖ • b • u = b • ‖u‖ • a • u
Theorem: Matrix.blockDiagonal_map
File: Mathlib/Data/Matrix/Block.lean

tactic: ext
state_before: l : Type ?u.129660
m : Type u_1
n : Type u_2
o : Type u_5
p : Type ?u.129672
q : Type ?u.129675
m' : o → Type ?u.129680
n' : o → Type ?u.129685
p' : o → Type ?u.129690
R : Type ?u.129693
S : Type ?u.129696
α : Type u_3
β : Type u_4
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
M : o → Matrix m n α
f : α → β
hf : f 0 = 0
⊢ map (blockDiagonal M) f = blockDiagonal fun k => map (M k) f

tactic: simp only [map_apply, blockDiagonal_apply, eq_comm]
state_before: case a.h
l : Type ?u.129660
m : Type u_1
n : Type u_2
o : Type u_5
p : Type ?u.129672
q : Type ?u.129675
m' : o → Type ?u.129680
n' : o → Type ?u.129685
p' : o → Type ?u.129690
R : Type ?u.129693
S : Type ?u.129696
α : Type u_3
β : Type u_4
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
M : o → Matrix m n α
f : α → β
hf : f 0 = 0
i✝ : m × o
x✝ : n × o
⊢ map (blockDiagonal M) f i✝ x✝ = blockDiagonal (fun k => map (M k) f) i✝ x✝

tactic: rw [apply_ite f, hf]
state_before: case a.h
l : Type ?u.129660
m : Type u_1
n : Type u_2
o : Type u_5
p : Type ?u.129672
q : Type ?u.129675
m' : o → Type ?u.129680
n' : o → Type ?u.129685
p' : o → Type ?u.129690
R : Type ?u.129693
S : Type ?u.129696
α : Type u_3
β : Type u_4
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
M : o → Matrix m n α
f : α → β
hf : f 0 = 0
i✝ : m × o
x✝ : n × o
⊢ f (if i✝.snd = x✝.snd then M i✝.snd i✝.fst x✝.fst else 0) = if i✝.snd = x✝.snd then f (M i✝.snd i✝.fst x✝.fst) else 0
Theorem: Bool.not_or_self
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (x : Bool), (!x || x) = true
Theorem: FormalMultilinearSeries.radius_eq_top_of_eventually_eq_zero
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simp [hn]
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.93541
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r✝ : ℝ≥0
h : ∀ᶠ (n : ℕ) in atTop, p n = 0
r : ℝ≥0
n : ℕ
hn : p n = 0
⊢ (fun _x => 0) n = (fun n => ‖p n‖ * ↑r ^ n) n
Theorem: Finset.induction_on_max
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction' s using Finset.strongInductionOn with s ihs
state_before: F : Type ?u.398044
α : Type u_1
β : Type ?u.398050
γ : Type ?u.398053
ι : Type ?u.398056
κ : Type ?u.398059
inst✝¹ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
inst✝ : DecidableEq α
p : Finset α → Prop
s : Finset α
h0 : p ∅
step : ∀ (a : α) (s : Finset α), (∀ (x : α), x ∈ s → x < a) → p s → p (insert a s)
⊢ p s

tactic: rcases s.eq_empty_or_nonempty with (rfl | hne)
state_before: case a
F : Type ?u.398044
α : Type u_1
β : Type ?u.398050
γ : Type ?u.398053
ι : Type ?u.398056
κ : Type ?u.398059
inst✝¹ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
inst✝ : DecidableEq α
p : Finset α → Prop
h0 : p ∅
step : ∀ (a : α) (s : Finset α), (∀ (x : α), x ∈ s → x < a) → p s → p (insert a s)
s : Finset α
ihs : ∀ (t : Finset α), t ⊂ s → p t
⊢ p s

tactic: exact h0
state_before: case a.inl
F : Type ?u.398044
α : Type u_1
β : Type ?u.398050
γ : Type ?u.398053
ι : Type ?u.398056
κ : Type ?u.398059
inst✝¹ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
inst✝ : DecidableEq α
p : Finset α → Prop
h0 : p ∅
step : ∀ (a : α) (s : Finset α), (∀ (x : α), x ∈ s → x < a) → p s → p (insert a s)
ihs : ∀ (t : Finset α), t ⊂ ∅ → p t
⊢ p ∅

tactic: have H : s.max' hne ∈ s := max'_mem s hne
state_before: case a.inr
F : Type ?u.398044
α : Type u_1
β : Type ?u.398050
γ : Type ?u.398053
ι : Type ?u.398056
κ : Type ?u.398059
inst✝¹ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
inst✝ : DecidableEq α
p : Finset α → Prop
h0 : p ∅
step : ∀ (a : α) (s : Finset α), (∀ (x : α), x ∈ s → x < a) → p s → p (insert a s)
s : Finset α
ihs : ∀ (t : Finset α), t ⊂ s → p t
hne : Finset.Nonempty s
⊢ p s

tactic: rw [← insert_erase H]
state_before: case a.inr
F : Type ?u.398044
α : Type u_1
β : Type ?u.398050
γ : Type ?u.398053
ι : Type ?u.398056
κ : Type ?u.398059
inst✝¹ : LinearOrder α
s✝ : Finset α
H✝ : Finset.Nonempty s✝
x : α
inst✝ : DecidableEq α
p : Finset α → Prop
h0 : p ∅
step : ∀ (a : α) (s : Finset α), (∀ (x : α), x ∈ s → x < a) → p s → p (insert a s)
s : Finset α
ihs : ∀ (t : Finset α), t ⊂ s → p t
hne : Finset.Nonempty s
H : max' s hne ∈ s
⊢ p s

tactic: exact step _ _ (fun x => s.lt_max'_of_mem_erase_max' hne) (ihs _ <| erase_ssubset H)
state_before: case a.inr
F : Type ?u.398044
α : Type u_1
β : Type ?u.398050
γ : Type ?u.398053
ι : Type ?u.398056
κ : Type ?u.398059
inst✝¹ : LinearOrder α
s✝ : Finset α
H✝ : Finset.Nonempty s✝
x : α
inst✝ : DecidableEq α
p : Finset α → Prop
h0 : p ∅
step : ∀ (a : α) (s : Finset α), (∀ (x : α), x ∈ s → x < a) → p s → p (insert a s)
s : Finset α
ihs : ∀ (t : Finset α), t ⊂ s → p t
hne : Finset.Nonempty s
H : max' s hne ∈ s
⊢ p (insert (max' s hne) (erase s (max' s hne)))
Theorem: WithBot.preimage_coe_Ioc
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ioc ↑a ↑b = Ioc a b
Theorem: Equiv.Perm.IsCycleOn.exists_pow_eq
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: classical
  obtain ⟨n, rfl⟩ := hf.2 ha hb
  obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.dvd
  refine' ⟨n.natMod s.card, Int.natMod_lt (Nonempty.card_pos ⟨a, ha⟩).ne', _⟩
  rw [← zpow_ofNat, Int.natMod,
    Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2
      (Nonempty.card_pos ⟨a, ha⟩).ne'),  sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
  simp only [zpow_coe_nat, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]
  exact IsFixedPt.perm_zpow (hf.pow_card_apply ha) _
state_before: ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
hb : b ∈ s
⊢ ∃ n, n < card s ∧ ↑(f ^ n) a = b

tactic: obtain ⟨n, rfl⟩ := hf.2 ha hb
state_before: ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
hb : b ∈ s
⊢ ∃ n, n < card s ∧ ↑(f ^ n) a = b

tactic: obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.dvd
state_before: case intro
ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℤ
hb : ↑(f ^ n) a ∈ s
⊢ ∃ n_1, n_1 < card s ∧ ↑(f ^ n_1) a = ↑(f ^ n) a

tactic: refine' ⟨n.natMod s.card, Int.natMod_lt (Nonempty.card_pos ⟨a, ha⟩).ne', _⟩
state_before: case intro.intro
ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℤ
hb : ↑(f ^ n) a ∈ s
k : ℤ
hk : n % ↑(card s) - n = ↑(card s) * k
⊢ ∃ n_1, n_1 < card s ∧ ↑(f ^ n_1) a = ↑(f ^ n) a

tactic: rw [← zpow_ofNat, Int.natMod,
  Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2
    (Nonempty.card_pos ⟨a, ha⟩).ne'),  sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
state_before: case intro.intro
ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℤ
hb : ↑(f ^ n) a ∈ s
k : ℤ
hk : n % ↑(card s) - n = ↑(card s) * k
⊢ ↑(f ^ Int.natMod n ↑(card s)) a = ↑(f ^ n) a

tactic: simp only [zpow_coe_nat, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]
state_before: case intro.intro
ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℤ
hb : ↑(f ^ n) a ∈ s
k : ℤ
hk : n % ↑(card s) - n = ↑(card s) * k
⊢ ↑(f ^ n * (f ^ ↑(card s)) ^ k) a = ↑(f ^ n) a

tactic: exact IsFixedPt.perm_zpow (hf.pow_card_apply ha) _
state_before: case intro.intro
ι : Type ?u.1885361
α : Type u_1
β : Type ?u.1885367
f g : Perm α
s✝ t : Set α
a x y : α
s : Finset α
hf : IsCycleOn f ↑s
ha : a ∈ s
n : ℤ
hb : ↑(f ^ n) a ∈ s
k : ℤ
hk : n % ↑(card s) - n = ↑(card s) * k
⊢ ↑((f ^ card s) ^ k) a = a
Theorem: xInTermsOfW_zero
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: rw [xInTermsOfW_eq, range_zero, sum_empty, pow_zero, C_1, mul_one, sub_zero]
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
inst✝ : Invertible ↑p
⊢ xInTermsOfW p R 0 = X 0
Theorem: Units.neg_divp
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [divp, neg_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ b a : α
u : αˣ
⊢ -(a /ₚ u) = -a /ₚ u
Theorem: HasDerivWithinAt.mul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: have := (HasFDerivWithinAt.mul' hc hd).hasDerivWithinAt
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 L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.197200
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
⊢ HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') s x

tactic: rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
  ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
  ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
  add_comm] at this
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 L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.197200
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
this : HasDerivWithinAt (fun y => c y * d y) (↑(c x • smulRight 1 d' + smulRight (smulRight 1 c') (d x)) 1) s x
⊢ HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') s x
Theorem: CategoryTheory.SimplicialObject.Augmented.w₀
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: convert congr_app f.w (op (SimplexCategory.mk 0))
state_before: C : Type u
inst✝ : Category C
X✝ : SimplicialObject C
X Y : Augmented C
f : X ⟶ Y
⊢ (drop.map f).app [0].op ≫ Y.hom.app [0].op = X.hom.app [0].op ≫ point.map f