tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.VectorMeasure.ext_iff'
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [← coe_injective.eq_iff, Function.funext_iff]
state_before: α : Type u_1
β : Type ?u.7710
m : MeasurableSpace α
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ v = w ↔ ∀ (i : Set α), ↑v i = ↑w i
Theorem: List.prod_reverse_noncomm
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp [prod_inv_reverse]
state_before: ι : Type ?u.114628
α : Type ?u.114631
M : Type ?u.114634
N : Type ?u.114637
P : Type ?u.114640
M₀ : Type ?u.114643
G : Type u_1
R : Type ?u.114649
inst✝ : Group G
⊢ ∀ (L : List G), prod (reverse L) = (prod (map (fun x => x⁻¹) L))⁻¹
Theorem: Ordinal.op_eq_self_of_principal
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine' le_antisymm _ (H.self_le _)
state_before: op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : IsLimit o
⊢ op a o = o

tactic: rw [← IsNormal.bsup_eq.{u, u} H ho', bsup_le_iff]
state_before: op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : IsLimit o
⊢ op a o ≤ o

tactic: exact fun b hbo => (ho hao hbo).le
state_before: op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : IsLimit o
⊢ ∀ (i : Ordinal), i < o → op a i ≤ o
Theorem: Set.Nontrivial.le_infsep_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [infsep, ← ENNReal.ofReal_le_iff_le_toReal hs.einfsep_ne_top, le_einfsep_iff, edist_dist,
  ENNReal.ofReal_le_ofReal_iff dist_nonneg]
state_before: α : Type u_1
β : Type ?u.58192
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : Set.Nontrivial s
⊢ d ≤ infsep s ↔ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → d ≤ dist x y
Theorem: CategoryTheory.NonPreadditiveAbelian.neg_sub
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: conv_lhs => rw [neg_def, ← sub_zero b, sub_sub_sub, sub_zero, ← neg_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ -a - b = -b - a
Theorem: RatFunc.num_div_denom
File: Mathlib/FieldTheory/RatFunc.lean

tactic: induction' x using RatFunc.induction_on with p q hq
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
⊢ ↑(algebraMap K[X] (RatFunc K)) (num x) / ↑(algebraMap K[X] (RatFunc K)) (denom x) = x

tactic: have q_div_ne_zero : q / gcd p q ≠ 0 := right_div_gcd_ne_zero hq
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) (num (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)) /
      ↑(algebraMap K[X] (RatFunc K)) (denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)) =
    ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q

tactic: dsimp only
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) (num (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)) /
      ↑(algebraMap K[X] (RatFunc K)) (denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)) =
    ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q

tactic: rw [num_div p q, denom_div p hq, RingHom.map_mul, RingHom.map_mul, mul_div_mul_left,
  div_eq_div_iff, ← RingHom.map_mul, ← RingHom.map_mul, mul_comm _ q, ←
  EuclideanDomain.mul_div_assoc, ← EuclideanDomain.mul_div_assoc, mul_comm]
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) (num (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)) /
      ↑(algebraMap K[X] (RatFunc K)) (denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q)) =
    ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q

tactic: apply gcd_dvd_right
state_before: case f.h
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ gcd p q ∣ q

tactic: apply gcd_dvd_left
state_before: case f.h
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ gcd p q ∣ p

tactic: exact algebraMap_ne_zero q_div_ne_zero
state_before: case f.hb
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) (q / gcd p q) ≠ 0

tactic: exact algebraMap_ne_zero hq
state_before: case f.hd
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) q ≠ 0

tactic: refine' algebraMap_ne_zero (mt Polynomial.C_eq_zero.mp _)
state_before: case f.hc
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ ↑(algebraMap K[X] (RatFunc K)) (↑C (leadingCoeff (q / gcd p q))⁻¹) ≠ 0

tactic: exact inv_ne_zero (Polynomial.leadingCoeff_ne_zero.mpr q_div_ne_zero)
state_before: case f.hc
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
q_div_ne_zero : q / gcd p q ≠ 0
⊢ ¬(leadingCoeff (q / gcd p q))⁻¹ = 0
Theorem: abs_sub_sq
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rw [abs_mul_abs_self]
state_before: α : Type u_1
inst✝ : LinearOrderedCommRing α
a✝ b✝ c d a b : α
⊢ abs (a - b) * abs (a - b) = a * a + b * b - (1 + 1) * a * b

tactic: simp only [mul_add, add_comm, add_left_comm, mul_comm, sub_eq_add_neg, mul_one, mul_neg,
  neg_add_rev, neg_neg, add_assoc]
state_before: α : Type u_1
inst✝ : LinearOrderedCommRing α
a✝ b✝ c d a b : α
⊢ (a - b) * (a - b) = a * a + b * b - (1 + 1) * a * b
Theorem: Quiver.Path.reverse_reverse
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

tactic: induction' p with _ _ _ _ h
state_before: U : Type ?u.6232
V : Type u_1
W : Type ?u.6238
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
p : Path a b
⊢ reverse (reverse p) = p

tactic: simp
state_before: case nil
U : Type ?u.6232
V : Type u_1
W : Type ?u.6238
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
⊢ reverse (reverse nil) = nil

tactic: rw [Path.reverse, Path.reverse_comp, h, Path.reverse_toPath, Quiver.reverse_reverse]
state_before: case cons
U : Type ?u.6232
V : Type u_1
W : Type ?u.6238
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h✝ : HasInvolutiveReverse V
a b b✝ c✝ : V
a✝¹ : Path a b✝
a✝ : b✝ ⟶ c✝
h : reverse (reverse a✝¹) = a✝¹
⊢ reverse (reverse (cons a✝¹ a✝)) = cons a✝¹ a✝

tactic: rfl
state_before: case cons
U : Type ?u.6232
V : Type u_1
W : Type ?u.6238
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h✝ : HasInvolutiveReverse V
a b b✝ c✝ : V
a✝¹ : Path a b✝
a✝ : b✝ ⟶ c✝
h : reverse (reverse a✝¹) = a✝¹
⊢ comp a✝¹ (Hom.toPath a✝) = cons a✝¹ a✝
Theorem: EMetric.hausdorffEdist_self_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [hausdorffEdist_zero_iff_closure_eq_closure, closure_closure]
state_before: ι : Sort ?u.51836
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
⊢ hausdorffEdist s (closure s) = 0
Theorem: MeasureTheory.OuterMeasure.comap_map
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [comap_apply, map_apply, hf.preimage_image]
state_before: α : Type u_2
β✝ : Type ?u.123348
R : Type ?u.123351
R' : Type ?u.123354
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
β : Type u_1
f : α → β
hf : Injective f
m : OuterMeasure α
s : Set α
⊢ ↑(↑(comap f) (↑(map f) m)) s = ↑m s
Theorem: Cycle.next_mem
File: Mathlib/Data/List/Cycle.lean

tactic: induction s using Quot.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Cycle α
hs : Nodup s
x : α
hx : x ∈ s
⊢ next s hs x hx ∈ s

tactic: apply next_mem
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
x : α
a✝ : List α
hs : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ next (Quot.mk Setoid.r a✝) hs x hx ∈ Quot.mk Setoid.r a✝

tactic: assumption
state_before: case h.h
α : Type u_1
inst✝ : DecidableEq α
x : α
a✝ : List α
hs : Nodup (Quot.mk Setoid.r a✝)
hx : x ∈ Quot.mk Setoid.r a✝
⊢ x ∈ a✝
Theorem: LocallyConvexSpace.ofBasisZero
File: Mathlib/Topology/Algebra/Module/LocallyConvex.lean

tactic: rw [← map_add_left_nhds_zero]
state_before: 𝕜 : Type u_3
E : Type u_2
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
ι : Type u_1
b : ι → Set E
p : ι → Prop
hbasis : HasBasis (𝓝 0) p b
hconvex : ∀ (i : ι), p i → Convex 𝕜 (b i)
x : E
⊢ HasBasis (𝓝 x) ((fun x => p) x) ((fun x i => (fun x x_1 => x + x_1) x '' b i) x)

tactic: exact hbasis.map _
state_before: 𝕜 : Type u_3
E : Type u_2
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
ι : Type u_1
b : ι → Set E
p : ι → Prop
hbasis : HasBasis (𝓝 0) p b
hconvex : ∀ (i : ι), p i → Convex 𝕜 (b i)
x : E
⊢ HasBasis (map ((fun x x_1 => x + x_1) x) (𝓝 0)) ((fun x => p) x) ((fun x i => (fun x x_1 => x + x_1) x '' b i) x)
Theorem: MeasureTheory.Measure.restrict_comm
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [restrict_restrict hs, restrict_restrict' hs, inter_comm]
state_before: α : Type u_1
β : Type ?u.291082
γ : Type ?u.291085
δ : Type ?u.291088
ι : Type ?u.291091
R : Type ?u.291094
R' : Type ?u.291097
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ restrict (restrict μ t) s = restrict (restrict μ s) t
Theorem: Ordnode.foldr_cons_eq_toList
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [foldr, foldr_cons_eq_toList l, foldr_cons_eq_toList r, ← List.cons_append,
    ← List.append_assoc, ← foldr_cons_eq_toList l]
state_before: α : Type u_1
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
r' : List α
⊢ foldr List.cons (node size✝ l x r) r' = toList (node size✝ l x r) ++ r'

tactic: rfl
state_before: α : Type u_1
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
r' : List α
⊢ foldr List.cons l (x :: toList r) ++ r' = toList (node size✝ l x r) ++ r'
Theorem: Set.preimage_const_sub_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iic, inter_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a - x) ⁻¹' Icc b c = Icc (a - c) (a - b)
Theorem: AffineSubspace.nonempty_iff_ne_bot
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [nonempty_iff_ne_empty]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ Set.Nonempty ↑Q ↔ Q ≠ ⊥

tactic: exact not_congr Q.coe_eq_bot_iff
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ ↑Q ≠ ∅ ↔ Q ≠ ⊥
Theorem: Real.exp_one_near_10
File: Mathlib/Data/Complex/ExponentialBounds.lean

tactic: apply exp_approx_start
state_before: ⊢ Abs.abs (exp 1 - 2244083 / 825552) ≤ 1 / 10 ^ 10

tactic: iterate 13 refine' exp_1_approx_succ_eq (by norm_num1; rfl) (by norm_cast) _
state_before: case h

⊢ Abs.abs (exp 1 - expNear 0 1 (2244083 / 825552)) ≤ Abs.abs 1 ^ 0 / ↑(Nat.factorial 0) * (1 / 10 ^ 10)

tactic: norm_num1
state_before: case h

⊢ Abs.abs
      (exp 1 -
        expNear 13 1
          ((((((((((((((2244083 / 825552 - 1) * 1 - 1) * 2 - 1) * 3 - 1) * 4 - 1) * 5 - 1) * 6 - 1) * 7 - 1) * 8 - 1) *
                            9 -
                          1) *
                        10 -
                      1) *
                    11 -
                  1) *
                12 -
              1) *
            13)) ≤
    Abs.abs 1 ^ 13 / ↑(Nat.factorial 13) * (1 / 10 ^ 10 * 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12 * 13)

tactic: refine' exp_approx_end' _ (by norm_num1; rfl) _ (by norm_cast) (by simp) _
state_before: case h

⊢ Abs.abs (exp 1 - expNear 13 1 (5 / 7)) ≤ Abs.abs 1 ^ 13 / ↑(Nat.factorial 13) * (243243 / 390625)

tactic: rw [_root_.abs_one, abs_of_pos] <;> norm_num1
state_before: case h

⊢ Abs.abs (1 - 5 / 7) ≤ 243243 / 390625 - Abs.abs 1 / 14 * ((14 + 1) / 14)

tactic: refine' exp_1_approx_succ_eq (by norm_num1; rfl) (by norm_cast) _
state_before: case h

⊢ Abs.abs
      (exp 1 -
        expNear 12 1
          (((((((((((((2244083 / 825552 - 1) * 1 - 1) * 2 - 1) * 3 - 1) * 4 - 1) * 5 - 1) * 6 - 1) * 7 - 1) * 8 - 1) *
                        9 -
                      1) *
                    10 -
                  1) *
                11 -
              1) *
            12)) ≤
    Abs.abs 1 ^ 12 / ↑(Nat.factorial 12) * (1 / 10 ^ 10 * 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12)

tactic: norm_num1
state_before: ⊢ 12 + 1 = ?m.1777

tactic: rfl
state_before: ⊢ 13 = ?m.1777

tactic: norm_cast
state_before: ⊢ ↑13 = ?m.1779

tactic: norm_num1
state_before: ⊢ 13 + 1 = ?m.2354

tactic: rfl
state_before: ⊢ 14 = ?m.2354

tactic: norm_cast
state_before: ⊢ ↑14 = ?m.2356

tactic: simp
state_before: ⊢ Abs.abs 1 ≤ 1
Theorem: ContinuousLinearMap.map_sub₂
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [f.map_sub, sub_apply]
state_before: 𝕜 : Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
E : Type ?u.212501
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
F : Type u_5
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedSpace 𝕜 F
G : Type ?u.212686
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedSpace 𝕜 G
R : Type u_1
𝕜₂ : Type u_7
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NontriviallyNormedField 𝕜₂
M : Type u_3
inst✝⁷ : TopologicalSpace M
σ₁₂ : 𝕜 →+* 𝕜₂
G' : Type u_4
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜₂ G'
inst✝⁴ : NormedSpace 𝕜' G'
inst✝³ : SMulCommClass 𝕜₂ 𝕜' G'
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ρ₁₂ : R →+* 𝕜'
f : M →SL[ρ₁₂] F →SL[σ₁₂] G'
x x' : M
y : F
⊢ ↑(↑f (x - x')) y = ↑(↑f x) y - ↑(↑f x') y
Theorem: WittVector.bind₁_onePoly_wittPolynomial
File: Mathlib/RingTheory/WittVector/IsPoly.lean

tactic: ext
state_before: p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ↑(bind₁ onePoly) (wittPolynomial p ℤ n) = 1

tactic: rw [wittPolynomial_eq_sum_c_mul_x_pow, AlgHom.map_sum, Finset.sum_eq_single 0]
state_before: case a
p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
m✝ : ℕ →₀ ℕ
⊢ MvPolynomial.coeff m✝ (↑(bind₁ onePoly) (wittPolynomial p ℤ n)) = MvPolynomial.coeff m✝ 1

tactic: simp only [onePoly, one_pow, one_mul, AlgHom.map_pow, C_1, pow_zero, bind₁_X_right, if_true,
  eq_self_iff_true]
state_before: case a
p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
m✝ : ℕ →₀ ℕ
⊢ MvPolynomial.coeff m✝ (↑(bind₁ onePoly) (↑C (↑p ^ 0) * X 0 ^ p ^ (n - 0))) = MvPolynomial.coeff m✝ 1

tactic: intro i _hi hi0
state_before: case a.h₀
p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
m✝ : ℕ →₀ ℕ
⊢ ∀ (b : ℕ), b ∈ Finset.range (n + 1) → b ≠ 0 → ↑(bind₁ onePoly) (↑C (↑p ^ b) * X b ^ p ^ (n - b)) = 0

tactic: simp only [onePoly, if_neg hi0, zero_pow (pow_pos hp.1.pos _), MulZeroClass.mul_zero,
  AlgHom.map_pow, bind₁_X_right, AlgHom.map_mul]
state_before: case a.h₀
p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
m✝ : ℕ →₀ ℕ
i : ℕ
_hi : i ∈ Finset.range (n + 1)
hi0 : i ≠ 0
⊢ ↑(bind₁ onePoly) (↑C (↑p ^ i) * X i ^ p ^ (n - i)) = 0

tactic: rw [Finset.mem_range]
state_before: case a.h₁
p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
m✝ : ℕ →₀ ℕ
⊢ ¬0 ∈ Finset.range (n + 1) → ↑(bind₁ onePoly) (↑C (↑p ^ 0) * X 0 ^ p ^ (n - 0)) = 0

tactic: simp only [add_pos_iff, or_true, not_true, pow_zero, map_one, ge_iff_le, nonpos_iff_eq_zero,
  tsub_zero, one_mul, gt_iff_lt, IsEmpty.forall_iff]
state_before: case a.h₁
p : ℕ
R S : Type u
σ : Type ?u.671892
idx : Type ?u.671895
inst✝¹ : CommRing R
inst✝ : CommRing S
hp : Fact (Nat.Prime p)
n : ℕ
m✝ : ℕ →₀ ℕ
⊢ ¬0 < n + 1 → ↑(bind₁ onePoly) (↑C (↑p ^ 0) * X 0 ^ p ^ (n - 0)) = 0
Theorem: AddCommGroup.DirectLimit.lift_unique
File: Mathlib/Algebra/DirectLimit.lean

tactic: simp
state_before: R : Type u
inst✝⁵ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝² : AddCommGroup P
g : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑(g j) (↑(f i j hij) x) = ↑(g i) x
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
F : DirectLimit G f →+ P
x✝ : DirectLimit G f
i j : ι
hij : i ≤ j
x : G i
⊢ ↑((fun i => AddMonoidHom.comp F (LinearMap.toAddMonoidHom (of G f i))) j) (↑(f i j hij) x) =
    ↑((fun i => AddMonoidHom.comp F (LinearMap.toAddMonoidHom (of G f i))) i) x

tactic: simp
state_before: R : Type u
inst✝⁵ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝² : AddCommGroup P
g : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑(g j) (↑(f i j hij) x) = ↑(g i) x
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
F : DirectLimit G f →+ P
x✝ : DirectLimit G f
i : ι
x : G i
⊢ ↑F (↑(of G f i) x) =
    ↑(lift G f P (fun i => AddMonoidHom.comp F (LinearMap.toAddMonoidHom (of G f i)))
          (_ : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑F (↑(of G f j) (↑(f i j hij) x)) = ↑F (↑(of G f i) x)))
      (↑(of G f i) x)
Theorem: FirstOrder.Language.BoundedFormula.realize_imp
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [Realize]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.53846
P : Type ?u.53849
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (φ ⟹ ψ) v xs ↔ Realize φ v xs → Realize ψ v xs
Theorem: Equiv.Perm.two_le_card_support_cycleOf_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine' ⟨fun h => _, fun h => by simpa using (isCycle_cycleOf _ h).two_le_card_support⟩
state_before: ι : Type ?u.2441167
α : Type u_1
β : Type ?u.2441173
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
⊢ 2 ≤ card (support (cycleOf f x)) ↔ ↑f x ≠ x

tactic: contrapose! h
state_before: ι : Type ?u.2441167
α : Type u_1
β : Type ?u.2441173
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : 2 ≤ card (support (cycleOf f x))
⊢ ↑f x ≠ x

tactic: rw [← cycleOf_eq_one_iff] at h
state_before: ι : Type ?u.2441167
α : Type u_1
β : Type ?u.2441173
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : ↑f x = x
⊢ card (support (cycleOf f x)) < 2

tactic: simp [h]
state_before: ι : Type ?u.2441167
α : Type u_1
β : Type ?u.2441173
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h✝ : ↑f x = x
h : cycleOf f x = 1
⊢ card (support (cycleOf f x)) < 2

tactic: simpa using (isCycle_cycleOf _ h).two_le_card_support
state_before: ι : Type ?u.2441167
α : Type u_1
β : Type ?u.2441173
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : ↑f x ≠ x
⊢ 2 ≤ card (support (cycleOf f x))
Theorem: ContinuousLinearMap.curry_uncurryLeft
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: ext (m x)
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei (succ i)) G
⊢ curryLeft (uncurryLeft f) = f

tactic: simp only [tail_cons, ContinuousLinearMap.uncurryLeft_apply,
  ContinuousMultilinearMap.curryLeft_apply]
state_before: case h.H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei (succ i)) G
m : Ei 0
x : (i : Fin n) → Ei (succ i)
⊢ ↑(↑(curryLeft (uncurryLeft f)) m) x = ↑(↑f m) x

tactic: rw [cons_zero]
state_before: case h.H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei (succ i)) G
m : Ei 0
x : (i : Fin n) → Ei (succ i)
⊢ ↑(↑f (Fin.cons m x 0)) x = ↑(↑f m) x
Theorem: Asymptotics.IsBigOWith.eq_zero_imp
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa [hg] using hx
state_before: α : Type u_1
β : Type ?u.192373
E : Type ?u.192376
F : Type ?u.192379
G : Type ?u.192382
E' : Type ?u.192385
F' : Type ?u.192388
G' : Type ?u.192391
E'' : Type u_2
F'' : Type u_3
G'' : Type ?u.192400
R : Type ?u.192403
R' : Type ?u.192406
𝕜 : Type ?u.192409
𝕜' : Type ?u.192412
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 α
h : IsBigOWith c l f'' g''
x : α
hx : ‖f'' x‖ ≤ c * ‖g'' x‖
hg : g'' x = 0
⊢ ‖f'' x‖ ≤ 0
Theorem: FixedPoints.minpoly.ne_one
File: Mathlib/FieldTheory/Fixed.lean

tactic: rwa [H, Polynomial.eval₂_one] at this
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
H : minpoly G F x = 1
this : Polynomial.eval₂ (Subring.subtype (subfield G F).toSubring) x (minpoly G F x) = 0
⊢ 1 = 0
Theorem: DMatrix.ext_iff
File: Mathlib/Data/Matrix/DMatrix.lean

tactic: simp [h]
state_before: l : Type ?u.172
m : Type u_1
n : Type u_2
o : Type ?u.181
inst✝³ : Fintype l
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : Fintype o
α : m → n → Type v
M N : DMatrix m n α
h : M = N
⊢ ∀ (i : m) (j : n), M i j = N i j