tasksource/leandojo huggingface dataset:
Theorem: List.range'_subset_right
File: Std/Data/List/Lemmas.lean

tactic: refine ⟨fun h => Nat.le_of_not_lt fun hn => ?_, fun h => (range'_sublist_right.2 h).subset⟩
state_before: step s m n : Nat
step0 : 0 < step
⊢ range' s m step ⊆ range' s n step ↔ m ≤ n

tactic: have ⟨i, h', e⟩ := mem_range'.1 <| h <| mem_range'.2 ⟨_, hn, rfl⟩
state_before: step s m n : Nat
step0 : 0 < step
h : range' s m step ⊆ range' s n step
hn : n < m
⊢ False

tactic: exact Nat.ne_of_gt h' (Nat.eq_of_mul_eq_mul_left step0 (Nat.add_left_cancel e))
state_before: step s m n : Nat
step0 : 0 < step
h : range' s m step ⊆ range' s n step
hn : n < m
i : Nat
h' : i < n
e : s + step * n = s + step * i
⊢ False
Theorem: Substring.Valid.data_take
File: Std/Data/String/Lemmas.lean

tactic: simp [(h.take _).toString, h.toString]
state_before: x✝¹ : Substring
h✝ : Valid x✝¹
x✝ : Nat
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝¹
⊢ (toString (Substring.take x✝¹ x✝)).data = List.take x✝ (toString x✝¹).data
Theorem: Orthonormal.equiv_refl
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [Orthonormal.equiv_apply, Equiv.coe_refl, id.def, LinearIsometryEquiv.coe_refl]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type ?u.3082509
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
ι' : Type ?u.3082561
ι'' : Type ?u.3082564
E' : Type ?u.3082567
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type ?u.3082585
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
v : Basis ι 𝕜 E
hv : Orthonormal 𝕜 ↑v
i : ι
⊢ ↑(equiv hv hv (Equiv.refl ι)) (↑v i) = ↑(LinearIsometryEquiv.refl 𝕜 E) (↑v i)
Theorem: Fin.one_lt_succ_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
a : Fin n
⊢ 1 < succ (succ a)

tactic: exact Fin.elim0 a
state_before: case zero
m : ℕ
a : Fin zero
⊢ 1 < succ (succ a)

tactic: rw [← succ_zero_eq_one, succ_lt_succ_iff]
state_before: case succ
m n✝ : ℕ
a : Fin (Nat.succ n✝)
⊢ 1 < succ (succ a)

tactic: exact succ_pos a
state_before: case succ
m n✝ : ℕ
a : Fin (Nat.succ n✝)
⊢ 0 < succ a
Theorem: Order.not_isPredLimit_pred_of_not_isMin
File: Mathlib/Order/SuccPred/Limit.lean

tactic: contrapose! ha
state_before: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : PredOrder α
ha : ¬IsMin a
⊢ ¬IsPredLimit (pred a)

tactic: exact ha.isMin
state_before: α : Type u_1
inst✝¹ : Preorder α
a : α
inst✝ : PredOrder α
ha : IsPredLimit (pred a)
⊢ IsMin a
Theorem: Filter.liminf_le_of_frequently_le'
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [liminf_eq]
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x : β
h : ∃ᶠ (a : α) in f, u a ≤ x
⊢ liminf u f ≤ x

tactic: refine' sSup_le fun b hb => _
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x : β
h : ∃ᶠ (a : α) in f, u a ≤ x
⊢ sSup {a | ∀ᶠ (n : α) in f, a ≤ u n} ≤ x

tactic: have hbx : ∃ᶠ _ in f, b ≤ x := by
  revert h
  rw [← not_imp_not, not_frequently, not_frequently]
  exact fun h => hb.mp (h.mono fun a hbx hba hax => hbx (hba.trans hax))
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x : β
h : ∃ᶠ (a : α) in f, u a ≤ x
b : β
hb : b ∈ {a | ∀ᶠ (n : α) in f, a ≤ u n}
⊢ b ≤ x

tactic: exact hbx.exists.choose_spec
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x : β
h : ∃ᶠ (a : α) in f, u a ≤ x
b : β
hb : b ∈ {a | ∀ᶠ (n : α) in f, a ≤ u n}
hbx : ∃ᶠ (x_1 : α) in f, b ≤ x
⊢ b ≤ x

tactic: revert h
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x : β
h : ∃ᶠ (a : α) in f, u a ≤ x
b : β
hb : b ∈ {a | ∀ᶠ (n : α) in f, a ≤ u n}
⊢ ∃ᶠ (x_1 : α) in f, b ≤ x

tactic: rw [← not_imp_not, not_frequently, not_frequently]
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x b : β
hb : b ∈ {a | ∀ᶠ (n : α) in f, a ≤ u n}
⊢ (∃ᶠ (a : α) in f, u a ≤ x) → ∃ᶠ (x_1 : α) in f, b ≤ x

tactic: exact fun h => hb.mp (h.mono fun a hbx hba hax => hbx (hba.trans hax))
state_before: α✝ : Type ?u.122316
β✝ : Type ?u.122319
γ : Type ?u.122322
ι : Type ?u.122325
inst✝¹ : CompleteLattice α✝
α : Type u_1
β : Type u_2
inst✝ : CompleteLattice β
f : Filter α
u : α → β
x b : β
hb : b ∈ {a | ∀ᶠ (n : α) in f, a ≤ u n}
⊢ (∀ᶠ (x_1 : α) in f, ¬b ≤ x) → ∀ᶠ (x_1 : α) in f, ¬u x_1 ≤ x
Theorem: Nat.ArithmeticFunction.coe_zeta_mul_coe_moebius
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [← coe_coe, ← intCoe_mul, coe_zeta_mul_moebius, intCoe_one]
state_before: R : Type u_1
inst✝ : Ring R
⊢ ↑ζ * ↑μ = 1
Theorem: Fin.succAbove_left_injective
File: Mathlib/Data/Fin/Basic.lean

tactic: simpa [range_succAbove] using congr_arg (fun f : Fin n ↪o Fin (n + 1) => Set.range fᶜ) h
state_before: n m : ℕ
x✝¹ x✝ : Fin (n + 1)
h : succAbove x✝¹ = succAbove x✝
⊢ x✝¹ = x✝
Theorem: norm_iteratedFDeriv_zero
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [iteratedFDeriv_zero_eq_comp, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ‖iteratedFDeriv 𝕜 0 f x‖ = ‖f x‖
Theorem: LieAlgebra.isNilpotent_range_ad_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
⊢ IsNilpotent R { x // x ∈ LieHom.range (ad R L) } ↔ IsNilpotent R L

tactic: have : (ad R L).ker = center R L := by simp
state_before: case refine'_1
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h : IsNilpotent R { x // x ∈ LieHom.range (ad R L) }
⊢ IsNilpotent R L

tactic: exact
  LieAlgebra.nilpotent_of_nilpotent_quotient (le_of_eq this)
    ((ad R L).quotKerEquivRange.nilpotent_iff_equiv_nilpotent.mpr h)
state_before: case refine'_1
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h : IsNilpotent R { x // x ∈ LieHom.range (ad R L) }
this : LieHom.ker (ad R L) = center R L
⊢ IsNilpotent R L

tactic: simp
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h : IsNilpotent R { x // x ∈ LieHom.range (ad R L) }
⊢ LieHom.ker (ad R L) = center R L

tactic: intro h
state_before: case refine'_2
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
⊢ IsNilpotent R L → IsNilpotent R { x // x ∈ LieHom.range (ad R L) }

tactic: exact (ad R L).isNilpotent_range
state_before: case refine'_2
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h : IsNilpotent R L
⊢ IsNilpotent R { x // x ∈ LieHom.range (ad R L) }
Theorem: ZMod.card_units
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: rw [Fintype.card_units, card]
state_before: K : Type ?u.1003941
R : Type ?u.1003944
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ Fintype.card (ZMod p)ˣ = p - 1
Theorem: IsROrC.I_im'
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [mul_comm, I_im]
state_before: K : Type u_1
E : Type ?u.2325884
inst✝ : IsROrC K
z : K
⊢ ↑im I * ↑im z = ↑im z
Theorem: MatrixEquivTensor.invFun_zero
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: simp [invFun]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ invFun R A n 0 = 0
Theorem: Function.LeftInverse.Prod_map
File: Mathlib/Data/Prod/Basic.lean

tactic: rw [Prod.map_map, hf.comp_eq_id, hg.comp_eq_id, map_id, id]
state_before: α : Type u_2
β : Type u_1
γ : Type u_4
δ : Type u_3
f : α → γ
g : β → δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
hf : LeftInverse f₁ f₂
hg : LeftInverse g₁ g₂
a : β × δ
⊢ map f₁ g₁ (map f₂ g₂ a) = a
Theorem: Finpartition.card_mono
File: Mathlib/Order/Partition/Finpartition.lean

tactic: classical
  have : ∀ b ∈ Q.parts, ∃ c ∈ P.parts, c ≤ b := fun b ↦ exists_le_of_le h
  choose f hP hf using this
  rw [← card_attach]
  refine' card_le_card_of_inj_on (fun b ↦ f _ b.2) (fun b _ ↦ hP _ b.2) fun b _ c _ h ↦ _
  exact
    Subtype.coe_injective
      (Q.disjoint.elim b.2 c.2 fun H ↦
        P.ne_bot (hP _ b.2) <| disjoint_self.1 <| H.mono (hf _ b.2) <| h.le.trans <| hf _ c.2)
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a : α
P Q : Finpartition a
h : P ≤ Q
⊢ card Q.parts ≤ card P.parts

tactic: have : ∀ b ∈ Q.parts, ∃ c ∈ P.parts, c ≤ b := fun b ↦ exists_le_of_le h
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a : α
P Q : Finpartition a
h : P ≤ Q
⊢ card Q.parts ≤ card P.parts

tactic: choose f hP hf using this
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a : α
P Q : Finpartition a
h : P ≤ Q
this : ∀ (b : α), b ∈ Q.parts → ∃ c, c ∈ P.parts ∧ c ≤ b
⊢ card Q.parts ≤ card P.parts

tactic: rw [← card_attach]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a : α
P Q : Finpartition a
h : P ≤ Q
f : (b : α) → b ∈ Q.parts → α
hP : ∀ (b : α) (a_1 : b ∈ Q.parts), f b a_1 ∈ P.parts
hf : ∀ (b : α) (a : b ∈ Q.parts), f b a ≤ b
⊢ card Q.parts ≤ card P.parts

tactic: refine' card_le_card_of_inj_on (fun b ↦ f _ b.2) (fun b _ ↦ hP _ b.2) fun b _ c _ h ↦ _
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a : α
P Q : Finpartition a
h : P ≤ Q
f : (b : α) → b ∈ Q.parts → α
hP : ∀ (b : α) (a_1 : b ∈ Q.parts), f b a_1 ∈ P.parts
hf : ∀ (b : α) (a : b ∈ Q.parts), f b a ≤ b
⊢ card (attach Q.parts) ≤ card P.parts

tactic: exact
  Subtype.coe_injective
    (Q.disjoint.elim b.2 c.2 fun H ↦
      P.ne_bot (hP _ b.2) <| disjoint_self.1 <| H.mono (hf _ b.2) <| h.le.trans <| hf _ c.2)
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a : α
P Q : Finpartition a
h✝ : P ≤ Q
f : (b : α) → b ∈ Q.parts → α
hP : ∀ (b : α) (a_1 : b ∈ Q.parts), f b a_1 ∈ P.parts
hf : ∀ (b : α) (a : b ∈ Q.parts), f b a ≤ b
b : { x // x ∈ Q.parts }
x✝¹ : b ∈ attach Q.parts
c : { x // x ∈ Q.parts }
x✝ : c ∈ attach Q.parts
h : (fun b => f ↑b (_ : ↑b ∈ Q.parts)) b = (fun b => f ↑b (_ : ↑b ∈ Q.parts)) c
⊢ b = c
Theorem: Equiv.prodCongr_refl_left
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
⊢ prodCongr (Equiv.refl α₁) e = prodCongrRight fun x => e

tactic: simp
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
a : α₁
b : β₁
⊢ ↑(prodCongr (Equiv.refl α₁) e) (a, b) = ↑(prodCongrRight fun x => e) (a, b)
Theorem: CategoryTheory.IsIso.of_mono_retraction'
File: Mathlib/CategoryTheory/EpiMono.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
hf : SplitMono f
inst✝ : Mono hf.retraction
⊢ f ≫ hf.retraction = 𝟙 X

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
X Y : C
f : X ⟶ Y
hf : SplitMono f
inst✝ : Mono hf.retraction
⊢ (hf.retraction ≫ f) ≫ hf.retraction = hf.retraction
Theorem: List.nthLe_enum
File: Mathlib/Data/List/Basic.lean

tactic: simpa [length_enum] using hi'
state_before: ι : Type ?u.461588
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
i : ℕ
hi' : i < length (enum l)
⊢ i < length l
Theorem: IsLowerSet.memberSubfamily
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

tactic: rintro s t hts
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
h : IsLowerSet ↑𝒜
⊢ IsLowerSet ↑(Finset.memberSubfamily a 𝒜)

tactic: simp_rw [mem_coe, mem_memberSubfamily]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s t : Finset α
hts : t ≤ s
⊢ s ∈ ↑(Finset.memberSubfamily a 𝒜) → t ∈ ↑(Finset.memberSubfamily a 𝒜)

tactic: exact And.imp (h <| insert_subset_insert _ hts) (mt <| @hts _)
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s t : Finset α
hts : t ≤ s
⊢ insert a s ∈ 𝒜 ∧ ¬a ∈ s → insert a t ∈ 𝒜 ∧ ¬a ∈ t
Theorem: FormalMultilinearSeries.norm_apply_eq_norm_coef
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: rw [← mkPiField_coeff_eq p, ContinuousMultilinearMap.norm_mkPiField]
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
n : ℕ
z z₀ : 𝕜
y : Fin n → 𝕜
⊢ ‖p n‖ = ‖coeff p n‖
Theorem: Semiquot.get_mem
File: Mathlib/Data/Semiquot.lean

tactic: let ⟨a, h⟩ := exists_mem q
state_before: α : Type u_1
β : Type ?u.15301
q : Semiquot α
p : IsPure q
⊢ get q p ∈ q

tactic: unfold get
state_before: α : Type u_1
β : Type ?u.15301
q : Semiquot α
p : IsPure q
a : α
h : a ∈ q
⊢ get q p ∈ q

tactic: rw [liftOn_ofMem q _ _ a h]
state_before: α : Type u_1
β : Type ?u.15301
q : Semiquot α
p : IsPure q
a : α
h : a ∈ q
⊢ liftOn q id p ∈ q

tactic: exact h
state_before: α : Type u_1
β : Type ?u.15301
q : Semiquot α
p : IsPure q
a : α
h : a ∈ q
⊢ id a ∈ q
Theorem: IsLocalization.isInteger_smul
File: Mathlib/RingTheory/Localization/Integer.lean

tactic: rcases hb with ⟨b', hb⟩
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.5566
inst✝ : CommRing P
a : R
b : S
hb : IsInteger R b
⊢ IsInteger R (a • b)

tactic: use a * b'
state_before: case intro
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.5566
inst✝ : CommRing P
a : R
b : S
b' : R
hb : ↑(algebraMap R S) b' = b
⊢ IsInteger R (a • b)

tactic: rw [← hb, (algebraMap R S).map_mul, Algebra.smul_def]
state_before: case intro
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.5566
inst✝ : CommRing P
a : R
b : S
b' : R
hb : ↑(algebraMap R S) b' = b
⊢ ↑(algebraMap R S) (a * b') = a • b
Theorem: ContinuousLinearMap.neg_comp
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁵ : Ring R
R₂ : Type u_2
inst✝¹⁴ : Ring R₂
R₃ : Type u_3
inst✝¹³ : Ring R₃
M : Type u_6
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommGroup M
M₂ : Type u_5
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommGroup M₂
M₃ : Type u_4
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommGroup M₃
M₄ : Type ?u.848558
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
⊢ comp (-g) f = -comp g f

tactic: simp
state_before: case h
R : Type u_1
inst✝¹⁵ : Ring R
R₂ : Type u_2
inst✝¹⁴ : Ring R₂
R₃ : Type u_3
inst✝¹³ : Ring R₃
M : Type u_6
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommGroup M
M₂ : Type u_5
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommGroup M₂
M₃ : Type u_4
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommGroup M₃
M₄ : Type ?u.848558
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
x✝ : M
⊢ ↑(comp (-g) f) x✝ = ↑(-comp g f) x✝
Theorem: ENNReal.one_lt_two
File: Mathlib/Data/Real/ENNReal.lean

tactic: exact_mod_cast (one_lt_two : 1 < 2)
state_before: α : Type ?u.33456
β : Type ?u.33459
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ↑1 < ↑2
Theorem: Bool.not_iff_not
File: Mathlib/Data/Bool/Basic.lean

tactic: simp
state_before: ⊢ ∀ {b : Bool}, (!b) = true ↔ ¬b = true
Theorem: FirstOrder.Sequence₂.sum_card
File: Mathlib/ModelTheory/Basic.lean

tactic: rw [sum_nat_eq_add_sum_succ, sum_nat_eq_add_sum_succ, sum_nat_eq_add_sum_succ]
state_before: a₀ a₁ a₂ : Type u
⊢ (sum fun i => #Sequence₂ a₀ a₁ a₂ i) = (#a₀) + (#a₁) + (#a₂)

tactic: simp [add_assoc, Sequence₂]
state_before: a₀ a₁ a₂ : Type u
⊢ (#Sequence₂ a₀ a₁ a₂ 0) +
      ((#Sequence₂ a₀ a₁ a₂ (0 + 1)) +
        ((#Sequence₂ a₀ a₁ a₂ (0 + 1 + 1)) + sum fun i => #Sequence₂ a₀ a₁ a₂ (i + 1 + 1 + 1))) =
    (#a₀) + (#a₁) + (#a₂)
Theorem: Filter.coprodᵢ_neBot_iff
File: Mathlib/Order/Filter/Pi.lean

tactic: simp [coprodᵢ_neBot_iff', *]
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), Nonempty (α i)
⊢ NeBot (Filter.coprodᵢ f) ↔ ∃ d, NeBot (f d)
Theorem: MeasureTheory.Measure.measure_toMeasurable_add_inter_left
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' (measure_inter_eq_of_measure_eq hs _ (subset_toMeasurable _ _) _).symm
state_before: α : Type u_1
β : Type ?u.140079
γ : Type ?u.140082
δ : Type ?u.140085
ι : Type ?u.140088
R : Type ?u.140091
R' : Type ?u.140094
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ↑↑(μ + ν) t ≠ ⊤
⊢ ↑↑μ (toMeasurable (μ + ν) t ∩ s) = ↑↑μ (t ∩ s)

tactic: refine'
  measure_eq_left_of_subset_of_measure_add_eq _ (subset_toMeasurable _ _)
    (measure_toMeasurable t).symm
state_before: case refine'_1
α : Type u_1
β : Type ?u.140079
γ : Type ?u.140082
δ : Type ?u.140085
ι : Type ?u.140088
R : Type ?u.140091
R' : Type ?u.140094
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ↑↑(μ + ν) t ≠ ⊤
⊢ ↑↑μ t = ↑↑μ (toMeasurable (μ + ν) t)

tactic: rwa [measure_toMeasurable t]
state_before: case refine'_1
α : Type u_1
β : Type ?u.140079
γ : Type ?u.140082
δ : Type ?u.140085
ι : Type ?u.140088
R : Type ?u.140091
R' : Type ?u.140094
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ↑↑(μ + ν) t ≠ ⊤
⊢ ↑↑(μ + ν) (toMeasurable (μ + ν) t) ≠ ⊤

tactic: simp only [not_or, ENNReal.add_eq_top, Pi.add_apply, Ne.def, coe_add] at ht
state_before: case refine'_2
α : Type u_1
β : Type ?u.140079
γ : Type ?u.140082
δ : Type ?u.140085
ι : Type ?u.140088
R : Type ?u.140091
R' : Type ?u.140094
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ↑↑(μ + ν) t ≠ ⊤
⊢ ↑↑μ t ≠ ⊤

tactic: exact ht.1
state_before: case refine'_2
α : Type u_1
β : Type ?u.140079
γ : Type ?u.140082
δ : Type ?u.140085
ι : Type ?u.140088
R : Type ?u.140091
R' : Type ?u.140094
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
hs : MeasurableSet s
ht : ¬↑↑μ t = ⊤ ∧ ¬↑↑ν t = ⊤
⊢ ↑↑μ t ≠ ⊤
Theorem: Matrix.one_dotProduct_one
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct, Fintype.card]
state_before: l : Type ?u.170404
m : Type ?u.170407
n : Type u_1
o : Type ?u.170413
m' : o → Type ?u.170418
n' : o → Type ?u.170423
R : Type ?u.170426
S : Type ?u.170429
α : Type v
β : Type w
γ : Type ?u.170436
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonAssocSemiring α
⊢ 1 ⬝ᵥ 1 = ↑(Fintype.card n)
Theorem: InnerProductGeometry.inner_eq_zero_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: simp (config := { contextual := true }) [angle, or_imp]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ angle x y = π / 2 ↔ inner x y = 0
Theorem: div_left_inj
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv]
state_before: α : Type ?u.60285
β : Type ?u.60288
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ b / a = c / a ↔ b = c

tactic: exact mul_left_inj _
state_before: α : Type ?u.60285
β : Type ?u.60288
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ b * a⁻¹ = c * a⁻¹ ↔ b = c
Theorem: LipschitzWith.iterate
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [pow_zero] using LipschitzWith.id
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → α
hf : LipschitzWith K f
⊢ LipschitzWith (K ^ 0) (f^[0])

tactic: rw [pow_succ']
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → α
hf : LipschitzWith K f
n : ℕ
⊢ LipschitzWith (K ^ (n + 1)) (f^[n + 1])

tactic: exact (LipschitzWith.iterate hf n).comp hf
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → α
hf : LipschitzWith K f
n : ℕ
⊢ LipschitzWith (K ^ n * K) (f^[n + 1])
Theorem: MeasureTheory.Measure.snd_univ
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [snd_apply MeasurableSet.univ, preimage_univ]
state_before: α : Type u_2
α' : Type ?u.5373035
β : Type u_1
β' : Type ?u.5373041
γ : Type ?u.5373044
E : Type ?u.5373047
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
ρ : Measure (α × β)
⊢ ↑↑(snd ρ) univ = ↑↑ρ univ
Theorem: Std.DList.ofList_toList
File: Mathlib/Data/DList/Basic.lean

tactic: cases' l with app inv
state_before: α : Type u_1
l : DList α
⊢ ofList (toList l) = l

tactic: simp only [ofList, toList, mk.injEq]
state_before: case mk
α : Type u_1
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList (toList { apply := app, invariant := inv }) = { apply := app, invariant := inv }

tactic: funext x
state_before: case mk
α : Type u_1
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app

tactic: rw [(inv x)]
state_before: case mk.h
α : Type u_1
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x