tasksource/leandojo huggingface dataset:
Theorem: SimpleGraph.Walk.chain_dartAdj_darts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p generalizing d with
| nil => exact List.Chain.nil
| cons h' p ih => exact List.Chain.cons (by exact h) (ih (by rfl))
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
d : Dart G
v w : V
h : d.snd = v
p : Walk G v w
⊢ List.Chain (DartAdj G) d (darts p)

tactic: exact List.Chain.nil
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ : V
d : Dart G
h : d.snd = u✝
⊢ List.Chain (DartAdj G) d (darts nil)

tactic: exact List.Chain.cons (by exact h) (ih (by rfl))
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.snd = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.snd = u✝
⊢ List.Chain (DartAdj G) d (darts (cons h' p))

tactic: exact h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.snd = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.snd = u✝
⊢ DartAdj G d { toProd := (u✝, v✝), is_adj := h' }

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u✝ v✝ w✝ : V
h' : Adj G u✝ v✝
p : Walk G v✝ w✝
ih : ∀ {d : Dart G}, d.snd = v✝ → List.Chain (DartAdj G) d (darts p)
d : Dart G
h : d.snd = u✝
⊢ { toProd := (u✝, v✝), is_adj := h' }.toProd.snd = v✝
Theorem: ModularGroup.T_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simpa using T_pow_mul_apply_one 1 g
state_before: g : SL(2, ℤ)
⊢ ↑(T * g) 1 = ↑g 1
Theorem: le_symmDiff_iff_right
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, le_symmDiff_iff_left, disjoint_comm]
state_before: ι : Type ?u.67558
α : Type u_1
β : Type ?u.67564
π : ι → Type ?u.67569
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ b ≤ a ∆ b ↔ Disjoint a b
Theorem: Matrix.blockDiagonal'_one
File: Mathlib/Data/Matrix/Block.lean

tactic: rw [blockDiagonal'_diagonal]
state_before: l : Type ?u.210158
m : Type ?u.210161
n : Type ?u.210164
o : Type u_3
p : Type ?u.210170
q : Type ?u.210173
m' : o → Type u_1
n' : o → Type ?u.210183
p' : o → Type ?u.210188
R : Type ?u.210191
S : Type ?u.210194
α : Type u_2
β : Type ?u.210200
inst✝⁴ : DecidableEq o
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : (i : o) → DecidableEq (m' i)
inst✝ : One α
⊢ (blockDiagonal' fun i => diagonal fun x => 1) = diagonal fun x => 1
Theorem: Dfinsupp.neLocus_neg
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: rw [← neLocus_neg_neg, neg_neg]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ neLocus (-f) g = neLocus f (-g)
Theorem: Fin.insertNth_sub_same
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp_rw [← insertNth_sub, ← insertNth_zero_right, Pi.sub_def, sub_self, Pi.zero_def]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (j : Fin (n + 1)) → AddGroup (α j)
i : Fin (n + 1)
x y : α i
p : (j : Fin n) → α (↑(succAbove i) j)
⊢ insertNth i x p - insertNth i y p = Pi.single i (x - y)
Theorem: VitaliFamily.ae_tendsto_measure_inter_div_of_measurableSet
File: Mathlib/MeasureTheory/Covering/Differentiation.lean

tactic: haveI : IsLocallyFiniteMeasure (μ.restrict s) :=
  isLocallyFiniteMeasure_of_le restrict_le_self
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
E : Type ?u.6149244
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : MeasureTheory.Measure α
inst✝ : IsLocallyFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
⊢ ∀ᵐ (x : α) ∂μ, Tendsto (fun a => ↑↑μ (s ∩ a) / ↑↑μ a) (filterAt v x) (𝓝 (indicator s 1 x))

tactic: filter_upwards [ae_tendsto_rnDeriv v (μ.restrict s), rnDeriv_restrict μ hs]
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
E : Type ?u.6149244
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : MeasureTheory.Measure α
inst✝ : IsLocallyFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
this : IsLocallyFiniteMeasure (Measure.restrict μ s)
⊢ ∀ᵐ (x : α) ∂μ, Tendsto (fun a => ↑↑μ (s ∩ a) / ↑↑μ a) (filterAt v x) (𝓝 (indicator s 1 x))

tactic: intro x hx h'x
state_before: case h
α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
E : Type ?u.6149244
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : MeasureTheory.Measure α
inst✝ : IsLocallyFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
this : IsLocallyFiniteMeasure (Measure.restrict μ s)
⊢ ∀ (a : α),
    Tendsto (fun a => ↑↑(Measure.restrict μ s) a / ↑↑μ a) (filterAt v a) (𝓝 (rnDeriv (Measure.restrict μ s) μ a)) →
      rnDeriv (Measure.restrict μ s) μ a = indicator s 1 a →
        Tendsto (fun a => ↑↑μ (s ∩ a) / ↑↑μ a) (filterAt v a) (𝓝 (indicator s 1 a))

tactic: simpa only [h'x, restrict_apply' hs, inter_comm] using hx
state_before: case h
α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
E : Type ?u.6149244
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : MeasureTheory.Measure α
inst✝ : IsLocallyFiniteMeasure ρ
s : Set α
hs : MeasurableSet s
this : IsLocallyFiniteMeasure (Measure.restrict μ s)
x : α
hx : Tendsto (fun a => ↑↑(Measure.restrict μ s) a / ↑↑μ a) (filterAt v x) (𝓝 (rnDeriv (Measure.restrict μ s) μ x))
h'x : rnDeriv (Measure.restrict μ s) μ x = indicator s 1 x
⊢ Tendsto (fun a => ↑↑μ (s ∩ a) / ↑↑μ a) (filterAt v x) (𝓝 (indicator s 1 x))
Theorem: Ideal.finprod_heightOneSpectrum_factorization_coe
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: conv_rhs => rw [← Ideal.finprod_heightOneSpectrum_factorization I hI]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ (∏ᶠ (v : HeightOneSpectrum R),
      ↑v.asIdeal ^ ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I)))) =
    ↑I

tactic: rw [FractionalIdeal.coeIdeal_finprod R⁰ K (le_refl _)]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ (∏ᶠ (v : HeightOneSpectrum R),
      ↑v.asIdeal ^ ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I)))) =
    ↑(∏ᶠ (v : HeightOneSpectrum R), maxPowDividing v I)

tactic: simp_rw [IsDedekindDomain.HeightOneSpectrum.maxPowDividing, FractionalIdeal.coeIdeal_pow,
  zpow_ofNat]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ (∏ᶠ (v : HeightOneSpectrum R),
      ↑v.asIdeal ^ ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I)))) =
    ∏ᶠ (a : HeightOneSpectrum R), ↑(maxPowDividing a I)
Theorem: AddSubgroup.norm_trivial_quotient_mk
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: refine' le_antisymm (opNorm_le_bound _ le_rfl fun x => _) (norm_nonneg _)
state_before: M : Type u_1
N : Type ?u.456398
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑(topologicalClosure S) = univ
⊢ ‖normedMk S‖ = 0

tactic: have hker : x ∈ S.normedMk.ker.topologicalClosure := by
  rw [S.ker_normedMk, ← SetLike.mem_coe, h]
  trivial
state_before: M : Type u_1
N : Type ?u.456398
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑(topologicalClosure S) = univ
x : M
⊢ ‖↑(normedMk S) x‖ ≤ 0 * ‖x‖

tactic: rw [ker_normedMk] at hker
state_before: M : Type u_1
N : Type ?u.456398
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑(topologicalClosure S) = univ
x : M
hker : x ∈ topologicalClosure (ker (normedMk S))
⊢ ‖↑(normedMk S) x‖ ≤ 0 * ‖x‖

tactic: simp only [(quotient_norm_eq_zero_iff S x).mpr hker, normedMk.apply, zero_mul, le_rfl]
state_before: M : Type u_1
N : Type ?u.456398
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑(topologicalClosure S) = univ
x : M
hker : x ∈ topologicalClosure S
⊢ ‖↑(normedMk S) x‖ ≤ 0 * ‖x‖

tactic: rw [S.ker_normedMk, ← SetLike.mem_coe, h]
state_before: M : Type u_1
N : Type ?u.456398
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑(topologicalClosure S) = univ
x : M
⊢ x ∈ topologicalClosure (ker (normedMk S))

tactic: trivial
state_before: M : Type u_1
N : Type ?u.456398
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
h : ↑(topologicalClosure S) = univ
x : M
⊢ x ∈ univ
Theorem: contDiff_succ_iff_has_fderiv
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [← contDiffOn_univ, ← hasFDerivWithinAt_univ,
  contDiffOn_succ_iff_has_fderiv_within uniqueDiffOn_univ, Set.mem_univ, forall_true_left]
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
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ ∃ f', ContDiff 𝕜 (↑n) f' ∧ ∀ (x : E), HasFDerivAt f (f' x) x
Theorem: RingEquiv.isDomain
File: Mathlib/Algebra/Ring/Equiv.lean

tactic: haveI : Nontrivial A := ⟨⟨e.symm 0, e.symm 1, e.symm.injective.ne zero_ne_one⟩⟩
state_before: F : Type ?u.113908
α : Type ?u.113911
β : Type ?u.113914
R : Type ?u.113917
S : Type ?u.113920
S' : Type ?u.113923
inst✝⁶ : Add R
inst✝⁵ : Add S
inst✝⁴ : Mul R
inst✝³ : Mul S
A : Type u_1
B : Type u_2
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : IsDomain B
e : A ≃+* B
⊢ IsDomain A

tactic: haveI := e.noZeroDivisors B
state_before: F : Type ?u.113908
α : Type ?u.113911
β : Type ?u.113914
R : Type ?u.113917
S : Type ?u.113920
S' : Type ?u.113923
inst✝⁶ : Add R
inst✝⁵ : Add S
inst✝⁴ : Mul R
inst✝³ : Mul S
A : Type u_1
B : Type u_2
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : IsDomain B
e : A ≃+* B
this : Nontrivial A
⊢ IsDomain A

tactic: exact NoZeroDivisors.to_isDomain _
state_before: F : Type ?u.113908
α : Type ?u.113911
β : Type ?u.113914
R : Type ?u.113917
S : Type ?u.113920
S' : Type ?u.113923
inst✝⁶ : Add R
inst✝⁵ : Add S
inst✝⁴ : Mul R
inst✝³ : Mul S
A : Type u_1
B : Type u_2
inst✝² : Ring A
inst✝¹ : Ring B
inst✝ : IsDomain B
e : A ≃+* B
this✝ : Nontrivial A
this : NoZeroDivisors A
⊢ IsDomain A
Theorem: SimpleGraph.cliqueFree_bot
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: intro t ht
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
⊢ CliqueFree ⊥ n

tactic: have := le_trans h (isNClique_bot_iff.1 ht).1
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
t : Finset α
ht : IsNClique ⊥ n t
⊢ False

tactic: simp only at this
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
t : Finset α
ht : IsNClique ⊥ n t
this : 2 ≤ 1
⊢ False
Theorem: LocalRing.of_surjective
File: Mathlib/RingTheory/Ideal/LocalRing.lean

tactic: intro a b hab
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ↑f
⊢ ∀ (a b : S), IsUnit (a + b) → IsUnit a ∨ IsUnit b

tactic: obtain ⟨a, rfl⟩ := hf a
state_before: R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ↑f
a b : S
hab : IsUnit (a + b)
⊢ IsUnit a ∨ IsUnit b

tactic: obtain ⟨b, rfl⟩ := hf b
state_before: case intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ↑f
b : S
a : R
hab : IsUnit (↑f a + b)
⊢ IsUnit (↑f a) ∨ IsUnit b

tactic: rw [← map_add] at hab
state_before: case intro.intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ↑f
a b : R
hab : IsUnit (↑f a + ↑f b)
⊢ IsUnit (↑f a) ∨ IsUnit (↑f b)

tactic: exact
  (isUnit_or_isUnit_of_isUnit_add <| IsLocalRingHom.map_nonunit _ hab).imp f.isUnit_map
    f.isUnit_map
state_before: case intro.intro
R : Type u
S : Type v
T : Type w
K : Type u'
inst✝⁴ : CommSemiring R
inst✝³ : LocalRing R
inst✝² : CommSemiring S
inst✝¹ : Nontrivial S
f : R →+* S
inst✝ : IsLocalRingHom f
hf : Function.Surjective ↑f
a b : R
hab : IsUnit (↑f (a + b))
⊢ IsUnit (↑f a) ∨ IsUnit (↑f b)
Theorem: List.rtakeWhile_concat_neg
File: Mathlib/Data/List/Rdrop.lean

tactic: rw [rtakeWhile_concat, if_neg h]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
h : ¬p x = true
⊢ rtakeWhile p (l ++ [x]) = []
Theorem: Nat.Linear.ExprCnstr.denote_toNormPoly
File: src/lean/Init/Data/Nat/Linear.lean

tactic: cases c
state_before: ctx : Context
c : ExprCnstr
⊢ PolyCnstr.denote ctx (toNormPoly c) = denote ctx c

tactic: rename_i eq lhs rhs
state_before: case mk
ctx : Context
eq✝ : Bool
lhs✝ rhs✝ : Expr
⊢ PolyCnstr.denote ctx (toNormPoly { eq := eq✝, lhs := lhs✝, rhs := rhs✝ }) =
    denote ctx { eq := eq✝, lhs := lhs✝, rhs := rhs✝ }

tactic: simp [ExprCnstr.denote, PolyCnstr.denote, ExprCnstr.toNormPoly]
state_before: case mk
ctx : Context
eq : Bool
lhs rhs : Expr
⊢ PolyCnstr.denote ctx (toNormPoly { eq := eq, lhs := lhs, rhs := rhs }) =
    denote ctx { eq := eq, lhs := lhs, rhs := rhs }

tactic: by_cases h : eq = true <;> simp [h]
state_before: case mk
ctx : Context
eq : Bool
lhs rhs : Expr
⊢ (bif eq then
      Poly.denote_eq ctx
        ((Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).fst,
          (Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).snd)
    else
      Poly.denote_le ctx
        ((Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).fst,
          (Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).snd)) =
    bif eq then Expr.denote ctx lhs = Expr.denote ctx rhs else Expr.denote ctx lhs ≤ Expr.denote ctx rhs

tactic: rw [Poly.denote_eq_cancel_eq]
state_before: case mk.inl
ctx : Context
eq : Bool
lhs rhs : Expr
h : eq = true
⊢ Poly.denote_eq ctx
      ((Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).fst,
        (Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).snd) =
    (Expr.denote ctx lhs = Expr.denote ctx rhs)

tactic: simp [Poly.denote_eq, Expr.toNormPoly, Poly.norm]
state_before: case mk.inl
ctx : Context
eq : Bool
lhs rhs : Expr
h : eq = true
⊢ Poly.denote_eq ctx (Expr.toNormPoly lhs, Expr.toNormPoly rhs) = (Expr.denote ctx lhs = Expr.denote ctx rhs)

tactic: rw [Poly.denote_le_cancel_eq]
state_before: case mk.inr
ctx : Context
eq : Bool
lhs rhs : Expr
h : ¬eq = true
⊢ Poly.denote_le ctx
      ((Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).fst,
        (Poly.cancel (Expr.toNormPoly lhs) (Expr.toNormPoly rhs)).snd) =
    (Expr.denote ctx lhs ≤ Expr.denote ctx rhs)

tactic: simp [Poly.denote_le, Expr.toNormPoly, Poly.norm]
state_before: case mk.inr
ctx : Context
eq : Bool
lhs rhs : Expr
h : ¬eq = true
⊢ Poly.denote_le ctx (Expr.toNormPoly lhs, Expr.toNormPoly rhs) = (Expr.denote ctx lhs ≤ Expr.denote ctx rhs)
Theorem: List.append_inj
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [append_inj (cons.inj h).2 (Nat.succ.inj hl)] at h ⊢
state_before: α : Type u_1
a : α
s₁ : List α
b : α
s₂ t₁ t₂ : List α
h : a :: s₁ ++ t₁ = b :: s₂ ++ t₂
hl : length (a :: s₁) = length (b :: s₂)
⊢ a :: s₁ = b :: s₂ ∧ t₁ = t₂

tactic: exact h
state_before: α : Type u_1
a : α
s₁ : List α
b : α
s₂ t₁ t₂ : List α
hl : length (a :: s₁) = length (b :: s₂)
h : a = b
⊢ a = b
Theorem: iteratedFDerivWithin_one_apply
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [iteratedFDerivWithin_succ_apply_left, iteratedFDerivWithin_zero_eq_comp,
  (continuousMultilinearCurryFin0 𝕜 E F).symm.comp_fderivWithin h]
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
h : UniqueDiffWithinAt 𝕜 s x
m : Fin 1 → E
⊢ ↑(iteratedFDerivWithin 𝕜 1 f s x) m = ↑(fderivWithin 𝕜 f s x) (m 0)

tactic: rfl
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
h : UniqueDiffWithinAt 𝕜 s x
m : Fin 1 → E
⊢ ↑(↑(ContinuousLinearMap.comp
              (↑(ContinuousLinearEquiv.mk
                  (LinearIsometryEquiv.symm (continuousMultilinearCurryFin0 𝕜 E F)).toLinearEquiv))
              (fderivWithin 𝕜 f s x))
          (m 0))
      (tail m) =
    ↑(fderivWithin 𝕜 f s x) (m 0)
Theorem: LinearMap.map_codRestrict
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simp [Subtype.ext_iff_val]
state_before: R : Type u_2
R₁ : Type ?u.1010618
R₂ : Type u_1
R₃ : Type ?u.1010624
R₄ : Type ?u.1010627
S : Type ?u.1010630
K : Type ?u.1010633
K₂ : Type ?u.1010636
M : Type u_3
M' : Type ?u.1010642
M₁ : Type ?u.1010645
M₂ : Type u_4
M₃ : Type ?u.1010651
M₄ : Type ?u.1010654
N : Type ?u.1010657
N₂ : Type ?u.1010660
ι : Type ?u.1010663
V : Type ?u.1010666
V₂ : Type ?u.1010669
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective σ₂₁
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
h : ∀ (c : M₂), ↑f c ∈ p
p' : Submodule R₂ M₂
x✝ : { x // x ∈ p }
x : M
hx : x ∈ p
⊢ { val := x, property := hx } ∈ map (codRestrict p f h) p' ↔
    { val := x, property := hx } ∈ comap (Submodule.subtype p) (map f p')
Theorem: Finset.singleton_product
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68532
s s' : Finset α
t t' : Finset β
a✝ : α
b : β
a : α
⊢ {a} ×ˢ t = map { toFun := Prod.mk a, inj' := (_ : Function.Injective (Prod.mk a)) } t

tactic: simp [and_left_comm, eq_comm]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type ?u.68532
s s' : Finset α
t t' : Finset β
a✝ : α
b : β
a x : α
y : β
⊢ (x, y) ∈ {a} ×ˢ t ↔ (x, y) ∈ map { toFun := Prod.mk a, inj' := (_ : Function.Injective (Prod.mk a)) } t
Theorem: gramSchmidt_def
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: rw [← sum_attach, attach_eq_univ, gramSchmidt]
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
n : ι
⊢ gramSchmidt 𝕜 f n = f n - ∑ i in Iio n, ↑(↑(orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i})) (f n))
Theorem: Nat.digits_lt_base
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases b with (_ | _ | b) <;> try simp_all
state_before: n b m d : ℕ
hb : 1 < b
hd : d ∈ digits b m
⊢ d < b

tactic: exact digits_lt_base' hd
state_before: case succ.succ
n m d b : ℕ
hd : d ∈ digits (succ (succ b)) m
⊢ d < succ (succ b)

tactic: simp_all
state_before: case succ.succ
n m d b : ℕ
hb : 1 < succ (succ b)
hd : d ∈ digits (succ (succ b)) m
⊢ d < succ (succ b)
Theorem: Equiv.Perm.toList_eq_nil_iff
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp [toList]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p✝ : Perm α
x✝ : α
p : Perm α
x : α
⊢ toList p x = [] ↔ ¬x ∈ support p
Theorem: measurableSet_insert
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rwa [← insert_eq_of_mem ha]
state_before: α : Type u_1
β : Type ?u.13146
γ : Type ?u.13149
δ : Type ?u.13152
δ' : Type ?u.13155
ι : Sort ?u.13158
s✝ t u : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : MeasurableSet (insert a s)
ha : a ∈ s
⊢ MeasurableSet s
Theorem: Real.cos_one_le
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp
state_before: ⊢ abs' 1 ≤ 1

tactic: norm_num
state_before: ⊢ abs' 1 ^ 4 * (5 / 96) + (1 - 1 ^ 2 / 2) ≤ 2 / 3
Theorem: LocalHomeomorph.extend_preimage_mem_nhds
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: apply (continuousAt_extend_symm f I h).preimage_mem_nhds
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.158773
M' : Type ?u.158776
H' : Type ?u.158779
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
h : x ∈ f.source
ht : t ∈ 𝓝 x
⊢ ↑(LocalEquiv.symm (extend f I)) ⁻¹' t ∈ 𝓝 (↑(extend f I) x)

tactic: rwa [(f.extend I).left_inv]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.158773
M' : Type ?u.158776
H' : Type ?u.158779
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
h : x ∈ f.source
ht : t ∈ 𝓝 x
⊢ t ∈ 𝓝 (↑(LocalEquiv.symm (extend f I)) (↑(extend f I) x))

tactic: rwa [f.extend_source]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.158773
M' : Type ?u.158776
H' : Type ?u.158779
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
h : x ∈ f.source
ht : t ∈ 𝓝 x
⊢ x ∈ (extend f I).source
Theorem: Rat.divInt_mul_right
File: Std/Data/Rat/Lemmas.lean

tactic: simp [← divInt_mul_left (d := d) a0, Int.mul_comm]
state_before: n d a : Int
a0 : a ≠ 0
⊢ n * a /. (d * a) = n /. d