tasksource/leandojo huggingface dataset:
Theorem: toIocMod_add_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocMod_add_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a (b + p) = toIocMod hp a b
Theorem: MeasureTheory.Egorov.mem_notConvergentSeq_iff
File: Mathlib/MeasureTheory/Function/Egorov.lean

tactic: simp_rw [notConvergentSeq, Set.mem_iUnion]
state_before: α : Type u_2
β : Type u_3
ι : Type u_1
m : MeasurableSpace α
inst✝¹ : MetricSpace β
μ : Measure α
n : ℕ
i j : ι
s : Set α
ε : ℝ
f : ι → α → β
g : α → β
inst✝ : Preorder ι
x : α
⊢ x ∈ notConvergentSeq f g n j ↔ ∃ k x_1, 1 / (↑n + 1) < dist (f k x) (g x)

tactic: rfl
state_before: α : Type u_2
β : Type u_3
ι : Type u_1
m : MeasurableSpace α
inst✝¹ : MetricSpace β
μ : Measure α
n : ℕ
i j : ι
s : Set α
ε : ℝ
f : ι → α → β
g : α → β
inst✝ : Preorder ι
x : α
⊢ (∃ i i_1, x ∈ {x | 1 / (↑n + 1) < dist (f i x) (g x)}) ↔ ∃ k x_1, 1 / (↑n + 1) < dist (f k x) (g x)
Theorem: finprod_cond_eq_right
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp [@eq_comm _ a]
state_before: α : Type u_2
β : Type ?u.340750
ι : Type ?u.340753
G : Type ?u.340756
M : Type u_1
N : Type ?u.340762
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
⊢ (∏ᶠ (i : α) (_ : a = i), f i) = f a
Theorem: Fintype.prod_dite
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: simp only [prod_dite, attach_eq_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.60200
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : CommMonoid β
f : (a : α) → p a → β
g : (a : α) → ¬p a → β
⊢ ∏ a : α, dite (p a) (f a) (g a) = (∏ a : { a // p a }, f ↑a (_ : p ↑a)) * ∏ a : { a // ¬p a }, g ↑a (_ : ¬p ↑a)

tactic: congr 1
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.60200
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : CommMonoid β
f : (a : α) → p a → β
g : (a : α) → ¬p a → β
⊢ (∏ x : { x // x ∈ filter (fun x => p x) univ }, f ↑x (_ : p ↑x)) *
      ∏ x : { x // x ∈ filter (fun x => ¬p x) univ }, g ↑x (_ : ¬p ↑x) =
    (∏ a : { a // p a }, f ↑a (_ : p ↑a)) * ∏ a : { a // ¬p a }, g ↑a (_ : ¬p ↑a)

tactic: exact (Equiv.subtypeEquivRight $ by simp).prod_comp fun x : { x // p x } => f x x.2
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type ?u.60200
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : CommMonoid β
f : (a : α) → p a → β
g : (a : α) → ¬p a → β
⊢ ∏ x : { x // x ∈ filter (fun x => p x) univ }, f ↑x (_ : p ↑x) = ∏ a : { a // p a }, f ↑a (_ : p ↑a)

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.60200
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : CommMonoid β
f : (a : α) → p a → β
g : (a : α) → ¬p a → β
⊢ ∀ (x : α), x ∈ filter (fun x => p x) univ ↔ p x

tactic: exact (Equiv.subtypeEquivRight $ by simp).prod_comp fun x : { x // ¬p x } => g x x.2
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type ?u.60200
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : CommMonoid β
f : (a : α) → p a → β
g : (a : α) → ¬p a → β
⊢ ∏ x : { x // x ∈ filter (fun x => ¬p x) univ }, g ↑x (_ : ¬p ↑x) = ∏ a : { a // ¬p a }, g ↑a (_ : ¬p ↑a)

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.60200
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : CommMonoid β
f : (a : α) → p a → β
g : (a : α) → ¬p a → β
⊢ ∀ (x : α), x ∈ filter (fun x => ¬p x) univ ↔ ¬p x
Theorem: Vector.nth_eq_nthLe
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [toList_length]
state_before: n : ℕ
α : Type ?u.12116
v : Vector α n
i : Fin n
⊢ ↑i < List.length (toList v)

tactic: exact i.2
state_before: n : ℕ
α : Type ?u.12116
v : Vector α n
i : Fin n
⊢ ↑i < n
Theorem: MeasureTheory.mul_meas_ge_le_pow_snorm'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: convert mul_meas_ge_le_pow_snorm μ hp_ne_zero hp_ne_top hf (ε ^ p.toReal) using 4
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4640914
G : Type ?u.4640917
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ε ^ ENNReal.toReal p * ↑↑μ {x | ε ≤ ↑‖f x‖₊} ≤ snorm f p μ ^ ENNReal.toReal p

tactic: ext x
state_before: case h.e'_3.h.e'_6.h.e'_3.h.e'_2
α : Type u_1
E : Type u_2
F : Type ?u.4640914
G : Type ?u.4640917
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (fun x => ε ≤ ↑‖f x‖₊) = fun x => ε ^ ENNReal.toReal p ≤ ↑‖f x‖₊ ^ ENNReal.toReal p

tactic: rw [ENNReal.rpow_le_rpow_iff (ENNReal.toReal_pos hp_ne_zero hp_ne_top)]
state_before: case h.e'_3.h.e'_6.h.e'_3.h.e'_2.h.a
α : Type u_1
E : Type u_2
F : Type ?u.4640914
G : Type ?u.4640917
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
x : α
⊢ ε ≤ ↑‖f x‖₊ ↔ ε ^ ENNReal.toReal p ≤ ↑‖f x‖₊ ^ ENNReal.toReal p
Theorem: Seminorm.mem_ball_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [mem_ball, sub_zero]
state_before: R : Type ?u.817019
R' : Type ?u.817022
𝕜 : Type u_2
𝕜₂ : Type ?u.817028
𝕜₃ : Type ?u.817031
𝕝 : Type ?u.817034
E : Type u_1
E₂ : Type ?u.817040
E₃ : Type ?u.817043
F : Type ?u.817046
G : Type ?u.817049
ι : Type ?u.817052
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x y : E
r : ℝ
⊢ y ∈ ball p 0 r ↔ ↑p y < r
Theorem: Fin.succ_one_eq_two
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
inst✝ : NeZero n
⊢ succ 1 = 2

tactic: exact (NeZero.ne 0 rfl).elim
state_before: case zero
m : ℕ
inst✝ : NeZero zero
⊢ succ 1 = 2

tactic: rfl
state_before: case succ
m n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
⊢ succ 1 = 2
Theorem: Matrix.adjugate_subsingleton
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext (i j)
state_before: m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
inst✝ : Subsingleton n
A : Matrix n n α
⊢ adjugate A = 1

tactic: simp [Subsingleton.elim i j, adjugate_apply, det_eq_elem_of_subsingleton _ i]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
inst✝ : Subsingleton n
A : Matrix n n α
i j : n
⊢ adjugate A i j = OfNat.ofNat 1 i j
Theorem: CategoryTheory.transferNatTransSelf_comm
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: rw [transferNatTransSelf_comp, gf, transferNatTransSelf_id]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
g : L₁ ⟶ L₂
gf : g ≫ f = 𝟙 L₁
⊢ ↑(transferNatTransSelf adj₁ adj₂) f ≫ ↑(transferNatTransSelf adj₂ adj₁) g = 𝟙 R₁
Theorem: PartENat.ne_top_iff_dom
File: Mathlib/Data/Nat/PartENat.lean

tactic: classical exact not_iff_comm.1 Part.eq_none_iff'.symm
state_before: x : PartENat
⊢ x ≠ ⊤ ↔ x.Dom

tactic: exact not_iff_comm.1 Part.eq_none_iff'.symm
state_before: x : PartENat
⊢ x ≠ ⊤ ↔ x.Dom
Theorem: Int.natAbs_le_self_sq
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [← Int.natAbs_sq a, sq]
state_before: α : Type ?u.316248
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
a : ℤ
⊢ ↑(natAbs a) ≤ a ^ 2

tactic: norm_cast
state_before: α : Type ?u.316248
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
a : ℤ
⊢ ↑(natAbs a) ≤ ↑(natAbs a) * ↑(natAbs a)

tactic: apply Nat.le_mul_self
state_before: α : Type ?u.316248
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
a : ℤ
⊢ natAbs a ≤ natAbs a * natAbs a
Theorem: Sym2.other_spec
File: Mathlib/Data/Sym/Sym2.lean

tactic: erw [← Classical.choose_spec h]
state_before: α : Type u_1
β : Type ?u.34981
γ : Type ?u.34984
a : α
z : Sym2 α
h : a ∈ z
⊢ Quotient.mk (Rel.setoid α) (a, Mem.other h) = z
Theorem: Set.directed_on_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [DirectedOn, exists_prop, mem_iUnion, exists_imp]
state_before: α : Type u_1
β : Type ?u.72615
γ : Type ?u.72618
ι : Sort u_2
ι' : Sort ?u.72624
ι₂ : Sort ?u.72627
κ : ι → Sort ?u.72632
κ₁ : ι → Sort ?u.72637
κ₂ : ι → Sort ?u.72642
κ' : ι' → Sort ?u.72647
r : α → α → Prop
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) f
h : ∀ (x : ι), DirectedOn r (f x)
⊢ DirectedOn r (⋃ (x : ι), f x)

tactic: exact fun a₁ b₁ fb₁ a₂ b₂ fb₂ =>
  let ⟨z, zb₁, zb₂⟩ := hd b₁ b₂
  let ⟨x, xf, xa₁, xa₂⟩ := h z a₁ (zb₁ fb₁) a₂ (zb₂ fb₂)
  ⟨x, ⟨z, xf⟩, xa₁, xa₂⟩
state_before: α : Type u_1
β : Type ?u.72615
γ : Type ?u.72618
ι : Sort u_2
ι' : Sort ?u.72624
ι₂ : Sort ?u.72627
κ : ι → Sort ?u.72632
κ₁ : ι → Sort ?u.72637
κ₂ : ι → Sort ?u.72642
κ' : ι' → Sort ?u.72647
r : α → α → Prop
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) f
h : ∀ (x : ι), DirectedOn r (f x)
⊢ ∀ (x : α) (x_1 : ι), x ∈ f x_1 → ∀ (y : α) (x_2 : ι), y ∈ f x_2 → ∃ z, (∃ i, z ∈ f i) ∧ r x z ∧ r y z
Theorem: Set.wellFoundedOn_insert
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp only [← singleton_union, wellFoundedOn_union, wellFoundedOn_singleton, true_and_iff]
state_before: ι : Type ?u.108524
α : Type u_1
β : Type ?u.108530
r : α → α → Prop
inst✝ : IsStrictOrder α r
s : Set α
a : α
⊢ WellFoundedOn (insert a s) r ↔ WellFoundedOn s r
Theorem: Submonoid.induction_of_closure_eq_top_right
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rw [hs]
state_before: M : Type u_1
A : Type ?u.92434
B : Type ?u.92437
inst✝ : Monoid M
s : Set M
p : M → Prop
hs : closure s = ⊤
x : M
H1 : p 1
Hmul : ∀ (x y : M), y ∈ s → p x → p (x * y)
⊢ x ∈ closure s

tactic: exact mem_top _
state_before: M : Type u_1
A : Type ?u.92434
B : Type ?u.92437
inst✝ : Monoid M
s : Set M
p : M → Prop
hs : closure s = ⊤
x : M
H1 : p 1
Hmul : ∀ (x y : M), y ∈ s → p x → p (x * y)
⊢ x ∈ ⊤
Theorem: AffineSubspace.sSameSide_vadd_right_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [sSameSide_comm, sSameSide_vadd_left_iff hv, sSameSide_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.138969
P : Type u_3
P' : Type ?u.138975
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
v : V
hv : v ∈ direction s
⊢ SSameSide s x (v +ᵥ y) ↔ SSameSide s x y
Theorem: TopologicalSpace.Opens.eq_bot_or_top
File: Mathlib/Topology/Sets/Opens.lean

tactic: subst h
state_before: ι : Type ?u.28720
α✝ : Type ?u.28723
β : Type ?u.28726
γ : Type ?u.28729
inst✝² : TopologicalSpace α✝
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
α : Type u_1
t : TopologicalSpace α
h : t = ⊤
U : Opens α
⊢ U = ⊥ ∨ U = ⊤

tactic: letI : TopologicalSpace α := ⊤
state_before: ι : Type ?u.28720
α✝ : Type ?u.28723
β : Type ?u.28726
γ : Type ?u.28729
inst✝² : TopologicalSpace α✝
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
α : Type u_1
U : Opens α
⊢ U = ⊥ ∨ U = ⊤

tactic: rw [← coe_eq_empty, ← coe_eq_univ, ← isOpen_top_iff]
state_before: ι : Type ?u.28720
α✝ : Type ?u.28723
β : Type ?u.28726
γ : Type ?u.28729
inst✝² : TopologicalSpace α✝
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
α : Type u_1
U : Opens α
this : TopologicalSpace α := ⊤
⊢ U = ⊥ ∨ U = ⊤

tactic: exact U.2
state_before: ι : Type ?u.28720
α✝ : Type ?u.28723
β : Type ?u.28726
γ : Type ?u.28729
inst✝² : TopologicalSpace α✝
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
α : Type u_1
U : Opens α
this : TopologicalSpace α := ⊤
⊢ IsOpen ↑U
Theorem: Commute.mul_inv_cancel
File: Mathlib/Algebra/Group/Commute.lean

tactic: rw [h.eq, mul_inv_cancel_right]
state_before: G : Type u_1
inst✝ : Group G
a b : G
h : Commute a b
⊢ a * b * a⁻¹ = b
Theorem: isSolvable_of_comm
File: Mathlib/GroupTheory/Solvable.lean

tactic: letI hG' : CommGroup G := { hG with mul_comm := h }
state_before: G✝ : Type ?u.40798
G' : Type ?u.40801
inst✝¹ : Group G✝
inst✝ : Group G'
f : G✝ →* G'
G : Type u_1
hG : Group G
h : ∀ (a b : G), a * b = b * a
⊢ IsSolvable G

tactic: cases hG
state_before: G✝ : Type ?u.40798
G' : Type ?u.40801
inst✝¹ : Group G✝
inst✝ : Group G'
f : G✝ →* G'
G : Type u_1
hG : Group G
h : ∀ (a b : G), a * b = b * a
hG' : CommGroup G := CommGroup.mk h
⊢ IsSolvable G

tactic: exact CommGroup.isSolvable
state_before: case mk
G✝ : Type ?u.40798
G' : Type ?u.40801
inst✝¹ : Group G✝
inst✝ : Group G'
f : G✝ →* G'
G : Type u_1
toDivInvMonoid✝ : DivInvMonoid G
mul_left_inv✝ : ∀ (a : G), a⁻¹ * a = 1
h : ∀ (a b : G), a * b = b * a
hG' : CommGroup G := CommGroup.mk h
⊢ IsSolvable G
Theorem: CategoryTheory.Functor.thin_diagram_of_surjective
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: simp_rw [← types_comp, ← F.map_comp, hφ]
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i✝ j✝ k✝ : J
s : Set (F.obj i✝)
inst✝ : IsCofilteredOrEmpty J
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
i j : J
f g : i ⟶ j
k : J
φ : k ⟶ i
hφ : φ ≫ f = φ ≫ g
⊢ (fun g => g ∘ F.map φ) (F.map f) = (fun g => g ∘ F.map φ) (F.map g)
Theorem: TensorProduct.ext_fourfold
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: ext w x y z
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.721821
inst✝¹³ : Monoid R'
R'' : Type ?u.721827
inst✝¹² : Semiring R''
M : Type u_5
N : Type u_4
P : Type u_3
Q : Type u_2
S : Type u_6
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
f : M →ₗ[R] N →ₗ[R] P
g h : ((M ⊗[R] N) ⊗[R] P) ⊗[R] Q →ₗ[R] S
H : ∀ (w : M) (x : N) (y : P) (z : Q), ↑g (((w ⊗ₜ[R] x) ⊗ₜ[R] y) ⊗ₜ[R] z) = ↑h (((w ⊗ₜ[R] x) ⊗ₜ[R] y) ⊗ₜ[R] z)
⊢ g = h

tactic: exact H w x y z
state_before: case H.H.H.h.h.h.h
R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.721821
inst✝¹³ : Monoid R'
R'' : Type ?u.721827
inst✝¹² : Semiring R''
M : Type u_5
N : Type u_4
P : Type u_3
Q : Type u_2
S : Type u_6
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
f : M →ₗ[R] N →ₗ[R] P
g h : ((M ⊗[R] N) ⊗[R] P) ⊗[R] Q →ₗ[R] S
H : ∀ (w : M) (x : N) (y : P) (z : Q), ↑g (((w ⊗ₜ[R] x) ⊗ₜ[R] y) ⊗ₜ[R] z) = ↑h (((w ⊗ₜ[R] x) ⊗ₜ[R] y) ⊗ₜ[R] z)
w : M
x : N
y : P
z : Q
⊢ ↑(↑(↑(↑(LinearMap.compr₂ (mk R M N)
                      (LinearMap.compr₂ (mk R (M ⊗[R] N) P) (LinearMap.compr₂ (mk R ((M ⊗[R] N) ⊗[R] P) Q) g)))
                  w)
              x)
          y)
      z =
    ↑(↑(↑(↑(LinearMap.compr₂ (mk R M N)
                      (LinearMap.compr₂ (mk R (M ⊗[R] N) P) (LinearMap.compr₂ (mk R ((M ⊗[R] N) ⊗[R] P) Q) h)))
                  w)
              x)
          y)
      z
Theorem: List.mem_cons
File: Std/Data/List/Lemmas.lean

tactic: cases h <;> simp [Membership.mem, *]
state_before: α✝ : Type u_1
a b : α✝
l : List α✝
h : a ∈ b :: l
⊢ a = b ∨ a ∈ l

tactic: constructor
state_before: α✝ : Type u_1
a b : α✝
l : List α✝
⊢ a ∈ a :: l

tactic: constructor
state_before: α✝ : Type u_1
a b✝ : α✝
l : List α✝
b : α✝
h : a ∈ l
⊢ a ∈ b :: l

tactic: assumption
state_before: case a
α✝ : Type u_1
a b✝ : α✝
l : List α✝
b : α✝
h : a ∈ l
⊢ Mem a l
Theorem: String.Iterator.ValidFor.pos_eq_endPos
File: Std/Data/String/Lemmas.lean

tactic: simp [h.pos, h.toString, Pos.ext_iff]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.i = endPos it.s ↔ r = []

tactic: exact (Nat.add_left_cancel_iff (m := 0)).trans <| eq_comm.trans utf8Len_eq_zero
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l = utf8Len l + utf8Len r ↔ r = []
Theorem: FiniteDimensional.finrank_finsupp
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: rw [finrank, rank_finsupp_self, ← mk_toNat_eq_card, toNat_lift]
state_before: R : Type u
M : Type v
N : Type w
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Module.Free R M
inst✝⁵ : Module.Finite R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
ι : Type v
inst✝ : Fintype ι
⊢ finrank R (ι →₀ R) = card ι
Theorem: IsCoprime.map
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [← f.map_mul, ← f.map_mul, ← f.map_add, h, f.map_one]
state_before: R : Type u
inst✝¹ : CommSemiring R
x y z : R
H : IsCoprime x y
S : Type v
inst✝ : CommSemiring S
f : R →+* S
a b : R
h : a * x + b * y = 1
⊢ ↑f a * ↑f x + ↑f b * ↑f y = 1
Theorem: Asymptotics.isLittleO_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def, IsBigOWith_def]
state_before: α : Type u_1
β : Type ?u.24923
E : Type u_2
F : Type u_3
G : Type ?u.24932
E' : Type ?u.24935
F' : Type ?u.24938
G' : Type ?u.24941
E'' : Type ?u.24944
F'' : Type ?u.24947
G'' : Type ?u.24950
R : Type ?u.24953
R' : Type ?u.24956
𝕜 : Type ?u.24959
𝕜' : Type ?u.24962
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''
k'' : α → G''
l l' : Filter α
⊢ f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖
Theorem: MvPowerSeries.smul_inv
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp [smul_eq_C_mul, mul_comm]
state_before: σ : Type u_1
R : Type ?u.2011824
k : Type u_2
inst✝ : Field k
r : k
φ : MvPowerSeries σ k
⊢ (r • φ)⁻¹ = r⁻¹ • φ⁻¹
Theorem: RingHom.map_det
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: simp [Matrix.det_apply', f.map_sum, f.map_prod]
state_before: m : Type ?u.1465983
n : Type u_1
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
S : Type w
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
⊢ ↑f (det M) = det (↑(RingHom.mapMatrix f) M)
Theorem: Submonoid.mem_sSup_of_directedOn
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: haveI : Nonempty S := Sne.to_subtype
state_before: M : Type u_1
A : Type ?u.37107
B : Type ?u.37110
inst✝ : MulOneClass M
S : Set (Submonoid M)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s

tactic: simp [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk]
state_before: M : Type u_1
A : Type ?u.37107
B : Type ?u.37110
inst✝ : MulOneClass M
S : Set (Submonoid M)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s
Theorem: Vector.get_cons_zero
File: Mathlib/Data/Vector/Basic.lean

tactic: simp [get_zero]
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α n
⊢ get (a ::ᵥ v) 0 = a
Theorem: FreeProduct.mrange_eq_iSup
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: apply le_antisymm (lift_mrange_le f fun i => le_iSup (fun i => MonoidHom.mrange (f i)) i)
state_before: ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.257223
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
⊢ MonoidHom.mrange (↑lift f) = ⨆ (i : ι), MonoidHom.mrange (f i)

tactic: apply iSup_le _
state_before: ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.257223
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
⊢ (⨆ (i : ι), MonoidHom.mrange (f i)) ≤ MonoidHom.mrange (↑lift f)

tactic: rintro i _ ⟨x, rfl⟩
state_before: ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.257223
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
⊢ ∀ (i : ι), MonoidHom.mrange (f i) ≤ MonoidHom.mrange (↑lift f)

tactic: exact ⟨of x, by simp only [lift_of]⟩
state_before: case intro
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.257223
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
i : ι
x : M i
⊢ ↑(f i) x ∈ MonoidHom.mrange (↑lift f)

tactic: simp only [lift_of]
state_before: ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.257223
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
i : ι
x : M i
⊢ ↑(↑lift f) (↑of x) = ↑(f i) x
Theorem: List.countp_cons
File: Mathlib/Data/List/Count.lean

tactic: by_cases h : p a <;> simp [h]
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
a : α
l : List α
⊢ countp p (a :: l) = countp p l + if p a = true then 1 else 0
Theorem: Set.prod_empty
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.6671
δ : Type ?u.6674
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ ∅ = ∅

tactic: exact and_false_iff _
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.6671
δ : Type ?u.6674
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x✝ : α × β
⊢ x✝ ∈ s ×ˢ ∅ ↔ x✝ ∈ ∅
Theorem: PNat.XgcdType.qp_eq
File: Mathlib/Data/PNat/Xgcd.lean

tactic: by_cases hq : u.q = 0
state_before: u : XgcdType
hr : r u = 0
⊢ q u = qp u + 1

tactic: let h := u.rq_eq
state_before: case pos
u : XgcdType
hr : r u = 0
hq : q u = 0
⊢ q u = qp u + 1

tactic: rw [hr, hq, mul_zero, add_zero] at h
state_before: case pos
u : XgcdType
hr : r u = 0
hq : q u = 0
h : r u + (u.bp + 1) * q u = u.ap + 1 := rq_eq u
⊢ q u = qp u + 1

tactic: cases h
state_before: case pos
u : XgcdType
hr : r u = 0
hq : q u = 0
h : 0 = u.ap + 1
⊢ q u = qp u + 1

tactic: exact (Nat.succ_pred_eq_of_pos (Nat.pos_of_ne_zero hq)).symm
state_before: case neg
u : XgcdType
hr : r u = 0
hq : ¬q u = 0
⊢ q u = qp u + 1
Theorem: Matrix.IsSymm.fromBlocks
File: Mathlib/LinearAlgebra/Matrix/Symmetric.lean

tactic: have hCB : Cᵀ = B := by
  rw [← hBC]
  simp
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
⊢ IsSymm (Matrix.fromBlocks A B C D)

tactic: unfold Matrix.IsSymm
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
hCB : Cᵀ = B
⊢ IsSymm (Matrix.fromBlocks A B C D)

tactic: rw [fromBlocks_transpose]
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
hCB : Cᵀ = B
⊢ (Matrix.fromBlocks A B C D)ᵀ = Matrix.fromBlocks A B C D

tactic: congr
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
hCB : Cᵀ = B
⊢ Matrix.fromBlocks Aᵀ Cᵀ Bᵀ Dᵀ = Matrix.fromBlocks A B C D

tactic: rw [hA, hCB, hBC, hD]
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
hCB : Cᵀ = B
⊢ Matrix.fromBlocks Aᵀ Cᵀ Bᵀ Dᵀ = Matrix.fromBlocks A B C D

tactic: rw [← hBC]
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
⊢ Cᵀ = B

tactic: simp
state_before: α : Type u_2
β : Type ?u.7912
n : Type u_3
m : Type u_1
R : Type ?u.7921
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsSymm A
hBC : Bᵀ = C
hD : IsSymm D
⊢ Bᵀᵀ = B