tasksource/leandojo huggingface dataset:
Theorem: LucasLehmer.sMod_succ
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: substs a b c
state_before: p : ℕ
a : ℤ
i : ℕ
b c : ℤ
h1 : 2 ^ p - 1 = a
h2 : sMod p i = b
h3 : (b * b - 2) % a = c
⊢ sMod p (i + 1) = c

tactic: rw [← sq]
state_before: p i : ℕ
⊢ sMod p (i + 1) = (sMod p i * sMod p i - 2) % (2 ^ p - 1)

tactic: rfl
state_before: p i : ℕ
⊢ sMod p (i + 1) = (sMod p i ^ 2 - 2) % (2 ^ p - 1)
Theorem: inv_thickening
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp_rw [thickening, ← infEdist_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ (thickening δ s)⁻¹ = thickening δ s⁻¹

tactic: rfl
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x | EMetric.infEdist x s < ENNReal.ofReal δ}⁻¹ = {x | EMetric.infEdist x⁻¹ s < ENNReal.ofReal δ}
Theorem: frontier_ball
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [frontier, closure_ball x hr, isOpen_ball.interior_eq, closedBall_diff_ball]
state_before: α : Type ?u.46464
β : Type ?u.46467
γ : Type ?u.46470
ι : Type ?u.46473
inst✝⁶ : NormedField α
inst✝⁵ : SeminormedAddCommGroup β
E : Type u_1
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace α E
F : Type ?u.46504
inst✝² : SeminormedAddCommGroup F
inst✝¹ : NormedSpace α F
inst✝ : NormedSpace ℝ E
x : E
r : ℝ
hr : r ≠ 0
⊢ frontier (ball x r) = sphere x r
Theorem: Finset.Pi.cons_injective
File: Mathlib/Data/Finset/Pi.lean

tactic: simpa only [Multiset.mem_cons, mem_insert] using h
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
a : α
b : δ a
s : Finset α
hs : ¬a ∈ s
e₁ e₂ : (a : α) → a ∈ s → δ a
eq : cons s a b e₁ = cons s a b e₂
e : α
h : e ∈ a ::ₘ s.val
⊢ e ∈ insert a s

tactic: simpa only [Multiset.mem_cons, mem_insert] using h
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
a : α
b : δ a
s : Finset α
hs : ¬a ∈ s
e₁ e₂ : (a : α) → a ∈ s → δ a
eq : cons s a b e₁ = cons s a b e₂
e : α
h : e ∈ a ::ₘ s.val
⊢ e ∈ insert a s

tactic: rw [eq]
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
a : α
b : δ a
s : Finset α
hs : ¬a ∈ s
e₁ e₂ : (a : α) → a ∈ s → δ a
eq : cons s a b e₁ = cons s a b e₂
e : α
h : e ∈ a ::ₘ s.val
⊢ cons s a b e₁ e (_ : e ∈ insert a s) = cons s a b e₂ e (_ : e ∈ insert a s)
Theorem: LinearMap.toSeminorm_comp
File: Mathlib/Analysis/LocallyConvex/WeakDual.lean

tactic: ext
state_before: 𝕜 : Type u_1
E : Type u_3
F : Type u_2
ι : Type ?u.17098
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
f : F →ₗ[𝕜] 𝕜
g : E →ₗ[𝕜] F
⊢ Seminorm.comp (toSeminorm f) g = toSeminorm (comp f g)

tactic: simp only [Seminorm.comp_apply, toSeminorm_apply, coe_comp, Function.comp_apply]
state_before: case h
𝕜 : Type u_1
E : Type u_3
F : Type u_2
ι : Type ?u.17098
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
f : F →ₗ[𝕜] 𝕜
g : E →ₗ[𝕜] F
x✝ : E
⊢ ↑(Seminorm.comp (toSeminorm f) g) x✝ = ↑(toSeminorm (comp f g)) x✝
Theorem: List.Perm.mem_iff
File: Mathlib/Data/List/Perm.lean

tactic: simp only [mem_cons, hs]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
x✝³ : α
x✝² x✝¹ : List α
x✝ : x✝² ~ x✝¹
hs : a ∈ x✝² ↔ a ∈ x✝¹
⊢ a ∈ x✝³ :: x✝² ↔ a ∈ x✝³ :: x✝¹

tactic: simp only [mem_cons, or_left_comm]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
x✝² x✝¹ : α
x✝ : List α
⊢ a ∈ x✝¹ :: x✝² :: x✝ ↔ a ∈ x✝² :: x✝¹ :: x✝
Theorem: Subgroup.map_injective_of_ker_le
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: apply_fun comap f  at hf
state_before: G : Type u_1
G' : Type ?u.602966
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.602975
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H K : Subgroup G
hH : ker f ≤ H
hK : ker f ≤ K
hf : map f H = map f K
⊢ H = K

tactic: rwa [comap_map_eq, comap_map_eq, sup_of_le_left hH, sup_of_le_left hK] at hf
state_before: G : Type u_1
G' : Type ?u.602966
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.602975
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H K : Subgroup G
hH : ker f ≤ H
hK : ker f ≤ K
hf : comap f (map f H) = comap f (map f K)
⊢ H = K
Theorem: Polynomial.eval₂_map
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval₂_eq_eval_map, eval₂_eq_eval_map, map_map]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
inst✝ : Semiring T
g : S →+* T
x : T
⊢ eval₂ g x (map f p) = eval₂ (RingHom.comp g f) x p
Theorem: MvPowerSeries.coeff_index_single_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp only [coeff_X, single_left_inj (one_ne_zero : (1 : ℕ) ≠ 0)]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
s t : σ
⊢ ↑(coeff R (single t 1)) (X s) = if t = s then 1 else 0
Theorem: MeasureTheory.AEEqFun.compMeasurable_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← compMeasurable_mk g hg f f.aestronglyMeasurable, mk_coeFn]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.389331
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ compMeasurable g hg f = mk (g ∘ ↑f) (_ : AEStronglyMeasurable (g ∘ ↑f) μ)
Theorem: Subtype.surjective_restrict
File: Mathlib/Data/Subtype.lean

tactic: letI := Classical.decPred p
state_before: α✝ : Sort ?u.6831
β✝ : Sort ?u.6834
γ : Sort ?u.6837
p✝ q : α✝ → Prop
α : Sort u_1
β : α → Type u_2
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
⊢ Surjective fun f => restrict p f

tactic: refine' fun f ↦ ⟨fun x ↦ if h : p x then f ⟨x, h⟩ else Nonempty.some (ne x), funext <| _⟩
state_before: α✝ : Sort ?u.6831
β✝ : Sort ?u.6834
γ : Sort ?u.6837
p✝ q : α✝ → Prop
α : Sort u_1
β : α → Type u_2
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
⊢ Surjective fun f => restrict p f

tactic: rintro ⟨x, hx⟩
state_before: α✝ : Sort ?u.6831
β✝ : Sort ?u.6834
γ : Sort ?u.6837
p✝ q : α✝ → Prop
α : Sort u_1
β : α → Type u_2
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
f : (x : Subtype p) → β ↑x
⊢ ∀ (x : Subtype p),
    (fun f => restrict p f)
        (fun x => if h : p x then f { val := x, property := h } else Nonempty.some (_ : Nonempty (β x))) x =
      f x

tactic: exact dif_pos hx
state_before: case mk
α✝ : Sort ?u.6831
β✝ : Sort ?u.6834
γ : Sort ?u.6837
p✝ q : α✝ → Prop
α : Sort u_1
β : α → Type u_2
ne : ∀ (a : α), Nonempty (β a)
p : α → Prop
this : DecidablePred p := Classical.decPred p
f : (x : Subtype p) → β ↑x
x : α
hx : p x
⊢ (fun f => restrict p f)
      (fun x => if h : p x then f { val := x, property := h } else Nonempty.some (_ : Nonempty (β x)))
      { val := x, property := hx } =
    f { val := x, property := hx }
Theorem: TypeVec.lastFun_toSubtype
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 2
state_before: n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
⊢ lastFun (toSubtype p) = _root_.id

tactic: induction i
state_before: case h
n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
i : last fun i => { x // ofRepeat (p i x) }
⊢ lastFun (toSubtype p) i = _root_.id i

tactic: simp [dropFun, *]
state_before: case h.mk
n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : ofRepeat (p Fin2.fz val✝)
⊢ lastFun (toSubtype p) { val := val✝, property := property✝ } = _root_.id { val := val✝, property := property✝ }

tactic: rfl
state_before: case h.mk
n : ℕ
α : TypeVec (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : ofRepeat (p Fin2.fz val✝)
⊢ lastFun (toSubtype p) { val := val✝, property := property✝ } = { val := val✝, property := property✝ }
Theorem: Ordinal.lt_blsub₂
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: convert lt_lsub.{v, u}
    (fun x : (Quotient.out.{u+2} o).α × (Quotient.out.{u+2} o).α =>
      op (typein.{u} LT.lt x.fst) (typein.{u} LT.lt x.snd))
    (Prod.mk.{u, u} (enum.{u} LT.lt a (by rwa [type_lt])) (enum.{u} LT.lt b (by rwa [type_lt])))
<;> simp only [typein_enum]
state_before: op : Ordinal → Ordinal → Ordinal
o a b : Ordinal
ha : a < o
hb : b < o
⊢ op a b < blsub₂ op o

tactic: rwa [type_lt]
state_before: op : Ordinal → Ordinal → Ordinal
o a b : Ordinal
ha : a < o
hb : b < o
⊢ a < type LT.lt

tactic: rwa [type_lt]
state_before: op : Ordinal → Ordinal → Ordinal
o a b : Ordinal
ha : a < o
hb : b < o
⊢ b < type LT.lt
Theorem: Polynomial.derivative_bit0
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp [bit0]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝ : Semiring R
a : R[X]
⊢ ↑derivative (bit0 a) = bit0 (↑derivative a)
Theorem: Polynomial.rootMultiplicity_eq_nat_find_of_nonzero
File: Mathlib/Data/Polynomial/Div.lean

tactic: dsimp [rootMultiplicity]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
p0 : p ≠ 0
a : R
⊢ rootMultiplicity a p = Nat.find (_ : multiplicity.Finite (X - ↑C a) p)

tactic: rw [dif_neg p0]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
p0 : p ≠ 0
a : R
⊢ (if h0 : p = 0 then 0 else Nat.find (_ : multiplicity.Finite (X - ↑C a) p)) =
    Nat.find (_ : multiplicity.Finite (X - ↑C a) p)

tactic: convert rfl
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
p0 : p ≠ 0
a : R
⊢ Nat.find (_ : multiplicity.Finite (X - ↑C a) p) = Nat.find (_ : multiplicity.Finite (X - ↑C a) p)
Theorem: IsROrC.normSq_add
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [normSq_apply, map_add, isROrC_simps]
state_before: K : Type u_1
E : Type ?u.4701150
inst✝ : IsROrC K
z w : K
⊢ ↑normSq (z + w) = ↑normSq z + ↑normSq w + 2 * ↑re (z * ↑(starRingEnd K) w)

tactic: ring
state_before: K : Type u_1
E : Type ?u.4701150
inst✝ : IsROrC K
z w : K
⊢ (↑re z + ↑re w) * (↑re z + ↑re w) + (↑im z + ↑im w) * (↑im z + ↑im w) =
    ↑re z * ↑re z + ↑im z * ↑im z + (↑re w * ↑re w + ↑im w * ↑im w) + 2 * (↑re z * ↑re w - ↑im z * -↑im w)
Theorem: Finset.coe_empty
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.21367
γ : Type ?u.21370
s : Finset α
⊢ ∀ (x : α), x ∈ ↑∅ ↔ x ∈ ∅
Theorem: Std.RBNode.Path.insertNew_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: simp [insertNew]
state_before: α : Type u_1
v : α
p : Path α
⊢ toList (insertNew p v) = withList p [v]
Theorem: TopCat.Sheaf.interUnionPullbackConeLift_right
File: Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean

tactic: erw [Category.assoc]
state_before: C : Type u
inst✝ : Category C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
⊢ interUnionPullbackConeLift F U V s ≫ F.val.map (homOfLE (_ : V ≤ U ⊔ V)).op = PullbackCone.snd s

tactic: simp_rw [← F.1.map_comp]
state_before: C : Type u
inst✝ : Category C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
⊢ IsLimit.lift
        (Nonempty.some
          (_ :
            Nonempty
              (IsLimit ((presheaf F).mapCone (Cocone.op (Pairwise.cocone fun j => WalkingPair.casesOn j.down U V))))))
        { pt := s.pt,
          π :=
            NatTrans.mk fun X_1 =>
              Opposite.casesOn X_1 fun unop =>
                Pairwise.casesOn unop
                  (fun a =>
                    ULift.casesOn a fun down => WalkingPair.casesOn down (PullbackCone.fst s) (PullbackCone.snd s))
                  fun a a_1 =>
                  ULift.casesOn a fun down =>
                    WalkingPair.casesOn down
                      (PullbackCone.fst s ≫
                        F.val.map (homOfLE (_ : U ⊓ (fun j => WalkingPair.casesOn j.down U V) a_1 ≤ U)).op)
                      (PullbackCone.snd s ≫
                        F.val.map (homOfLE (_ : V ⊓ (fun j => WalkingPair.casesOn j.down U V) a_1 ≤ V)).op) } ≫
      F.val.map (eqToHom (_ : U ⊔ V = ⨆ (j : ULift WalkingPair), WalkingPair.casesOn j.down U V)).op ≫
        F.val.map (homOfLE (_ : V ≤ U ⊔ V)).op =
    PullbackCone.snd s

tactic: exact
  (F.presheaf.isSheaf_iff_isSheafPairwiseIntersections.mp F.2 _).some.fac _ <|
    op <| Pairwise.single <| ULift.up WalkingPair.right
state_before: C : Type u
inst✝ : Category C
X : TopCat
F : Sheaf C X
U V : Opens ↑X
s : PullbackCone (F.val.map (homOfLE (_ : U ⊓ V ≤ U)).op) (F.val.map (homOfLE (_ : U ⊓ V ≤ V)).op)
⊢ IsLimit.lift
        (Nonempty.some
          (_ :
            Nonempty
              (IsLimit ((presheaf F).mapCone (Cocone.op (Pairwise.cocone fun j => WalkingPair.casesOn j.down U V))))))
        { pt := s.pt,
          π :=
            NatTrans.mk fun X_1 =>
              Pairwise.rec (fun a => WalkingPair.rec (PullbackCone.fst s) (PullbackCone.snd s) a.down)
                (fun a a_1 =>
                  WalkingPair.rec
                    (PullbackCone.fst s ≫ F.val.map (homOfLE (_ : U ⊓ WalkingPair.rec U V a_1.down ≤ U)).op)
                    (PullbackCone.snd s ≫ F.val.map (homOfLE (_ : V ⊓ WalkingPair.rec U V a_1.down ≤ V)).op) a.down)
                X_1.unop } ≫
      F.val.map
        ((eqToHom (_ : U ⊔ V = ⨆ (j : ULift WalkingPair), WalkingPair.casesOn j.down U V)).op ≫
          (homOfLE (_ : V ≤ U ⊔ V)).op) =
    PullbackCone.snd s
Theorem: Filter.liminf_nat_add
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp_rw [liminf_eq_iSup_iInf_of_nat]
state_before: α : Type u_1
β : Type ?u.121287
γ : Type ?u.121290
ι : Type ?u.121293
inst✝ : CompleteLattice α
f : ℕ → α
k : ℕ
⊢ liminf (fun i => f (i + k)) atTop = liminf f atTop

tactic: exact iSup_iInf_ge_nat_add f k
state_before: α : Type u_1
β : Type ?u.121287
γ : Type ?u.121290
ι : Type ?u.121293
inst✝ : CompleteLattice α
f : ℕ → α
k : ℕ
⊢ (⨆ (n : ℕ), ⨅ (i : ℕ) (_ : i ≥ n), f (i + k)) = ⨆ (n : ℕ), ⨅ (i : ℕ) (_ : i ≥ n), f i
Theorem: MeasureTheory.aefinStronglyMeasurable_iff_aemeasurable
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp_rw [AEFinStronglyMeasurable, AEMeasurable, finStronglyMeasurable_iff_measurable]
state_before: α : Type u_1
β : Type ?u.554675
γ : Type ?u.554678
ι : Type ?u.554681
inst✝⁵ : Countable ι
G : Type u_2
p : ℝ≥0∞
m m0 : MeasurableSpace α
μ✝ : Measure α
inst✝⁴ : SeminormedAddCommGroup G
inst✝³ : MeasurableSpace G
inst✝² : BorelSpace G
inst✝¹ : SecondCountableTopology G
f : α → G
_m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
⊢ AEFinStronglyMeasurable f μ ↔ AEMeasurable f
Theorem: GaloisInsertion.l_biSup_u
File: Mathlib/Order/GaloisConnection.lean

tactic: simp only [iSup_subtype', gi.l_iSup_u]
state_before: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort ?u.38746
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
p : ι → Prop
f : (i : ι) → p i → β
⊢ l (⨆ (i : ι) (hi : p i), u (f i hi)) = ⨆ (i : ι) (hi : p i), f i hi
Theorem: Associates.mk_ne_zero'
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [Associates.mk_ne_zero, Ideal.zero_eq_bot, Ne.def, Ideal.span_singleton_eq_bot]
state_before: R : Type u_1
inst✝ : CommSemiring R
r : R
⊢ Associates.mk (Ideal.span {r}) ≠ 0 ↔ r ≠ 0
Theorem: SimpleGraph.toGraph_adjMatrix_eq
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: ext
state_before: V : Type u_2
α : Type u_1
β : Type ?u.29980
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
⊢ IsAdjMatrix.toGraph (_ : IsAdjMatrix (adjMatrix α G)) = G

tactic: simp only [IsAdjMatrix.toGraph_Adj, adjMatrix_apply, ite_eq_left_iff, zero_ne_one]
state_before: case Adj.h.h.a
V : Type u_2
α : Type u_1
β : Type ?u.29980
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
x✝¹ x✝ : V
⊢ Adj (IsAdjMatrix.toGraph (_ : IsAdjMatrix (adjMatrix α G))) x✝¹ x✝ ↔ Adj G x✝¹ x✝

tactic: apply Classical.not_not
state_before: case Adj.h.h.a
V : Type u_2
α : Type u_1
β : Type ?u.29980
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
x✝¹ x✝ : V
⊢ ¬Adj G x✝¹ x✝ → False ↔ Adj G x✝¹ x✝
Theorem: MonoidHom.coprod_comp_inl
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp [coprod_apply]
state_before: A : Type ?u.64869
B : Type ?u.64872
G : Type ?u.64875
H : Type ?u.64878
M : Type u_1
N : Type u_3
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommMonoid P
f : M →* P
g : N →* P
x : M
⊢ ↑(comp (coprod f g) (inl M N)) x = ↑f x
Theorem: Equiv.prodCongrLeft_trans_prodComm
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_3
β₁ : Type u_2
β₂ : Type u_1
e : α₁ → β₁ ≃ β₂
⊢ (prodCongrLeft e).trans (prodComm β₂ α₁) = (prodComm β₁ α₁).trans (prodCongrRight e)

tactic: simp
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_2
β₂ : Type u_1
e : α₁ → β₁ ≃ β₂
a : β₁
b : α₁
⊢ ↑((prodCongrLeft e).trans (prodComm β₂ α₁)) (a, b) = ↑((prodComm β₁ α₁).trans (prodCongrRight e)) (a, b)
Theorem: Set.image_update_Icc_right
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simpa using image_update_Icc f i (f i) b
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
b : α i
⊢ update f i '' Icc (f i) b = Icc f (update f i b)
Theorem: OrthonormalBasis.coe_mk
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: classical rw [OrthonormalBasis.mk, _root_.Basis.coe_toOrthonormalBasis, Basis.coe_mk]
state_before: ι : Type u_3
ι' : Type ?u.1163327
𝕜 : Type u_1
inst✝⁹ : IsROrC 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.1163356
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.1163374
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.1163394
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : ι → E
hon : Orthonormal 𝕜 v
hsp : ⊤ ≤ span 𝕜 (range v)
⊢ ↑(OrthonormalBasis.mk hon hsp) = v

tactic: rw [OrthonormalBasis.mk, _root_.Basis.coe_toOrthonormalBasis, Basis.coe_mk]
state_before: ι : Type u_3
ι' : Type ?u.1163327
𝕜 : Type u_1
inst✝⁹ : IsROrC 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.1163356
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.1163374
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.1163394
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : ι → E
hon : Orthonormal 𝕜 v
hsp : ⊤ ≤ span 𝕜 (range v)
⊢ ↑(OrthonormalBasis.mk hon hsp) = v
Theorem: multiplicity.finite_nat_iff
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← not_iff_not, not_finite_iff_forall, not_and_or, Ne.def, Classical.not_not, not_lt,
  le_zero_iff]
state_before: α : Type ?u.1244493
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
⊢ Finite a b ↔ a ≠ 1 ∧ 0 < b

tactic: exact
  ⟨fun h =>
    or_iff_not_imp_right.2 fun hb =>
      have ha : a ≠ 0 := fun ha => hb <| zero_dvd_iff.mp <| by rw [ha] at h; exact h 1
      Classical.by_contradiction fun ha1 : a ≠ 1 =>
        have ha_gt_one : 1 < a :=
          lt_of_not_ge fun _ =>
            match a with
            | 0 => ha rfl
            | 1 => ha1 rfl
            | b+2 => by linarith
        not_lt_of_ge (le_of_dvd (Nat.pos_of_ne_zero hb) (h b)) (lt_pow_self ha_gt_one b),
    fun h => by cases h <;> simp [*]⟩
state_before: α : Type ?u.1244493
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
⊢ (∀ (n : ℕ), a ^ n ∣ b) ↔ a = 1 ∨ b = 0

tactic: rw [ha] at h
state_before: α : Type ?u.1244493
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
h : ∀ (n : ℕ), a ^ n ∣ b
hb : ¬b = 0
ha : a = 0
⊢ 0 ∣ b

tactic: exact h 1
state_before: α : Type ?u.1244493
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
h : ∀ (n : ℕ), 0 ^ n ∣ b
hb : ¬b = 0
ha : a = 0
⊢ 0 ∣ b

tactic: linarith
state_before: α : Type ?u.1244493
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b✝ : ℕ
hb : ¬b✝ = 0
b : ℕ
h : ∀ (n : ℕ), (b + 2) ^ n ∣ b✝
ha : b + 2 ≠ 0
ha1 : b + 2 ≠ 1
x✝ : 1 ≥ b + 2
⊢ False

tactic: cases h <;> simp [*]
state_before: α : Type ?u.1244493
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
h : a = 1 ∨ b = 0
⊢ ∀ (n : ℕ), a ^ n ∣ b
Theorem: Finset.id_traverse
File: Mathlib/Data/Finset/Functor.lean

tactic: rw [traverse, Multiset.id_traverse]
state_before: α β γ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : CommApplicative F
inst✝¹ : CommApplicative G
inst✝ : DecidableEq α
s : Finset α
⊢ traverse pure s = s

tactic: exact s.val_toFinset
state_before: α β γ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : CommApplicative F
inst✝¹ : CommApplicative G
inst✝ : DecidableEq α
s : Finset α
⊢ Multiset.toFinset <$> s.val = s
Theorem: ProbabilityTheory.kernel.IsMarkovKernel.comapRight
File: Mathlib/Probability/Kernel/Basic.lean

tactic: refine' ⟨fun a => ⟨_⟩⟩
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1453265
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
γ : Type u_3
mγ : MeasurableSpace γ
f : γ → β
κ : { x // x ∈ kernel α β }
hf : MeasurableEmbedding f
hκ : ∀ (a : α), ↑↑(↑κ a) (Set.range f) = 1
⊢ IsMarkovKernel (kernel.comapRight κ hf)

tactic: rw [comapRight_apply' κ hf a MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1453265
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
γ : Type u_3
mγ : MeasurableSpace γ
f : γ → β
κ : { x // x ∈ kernel α β }
hf : MeasurableEmbedding f
hκ : ∀ (a : α), ↑↑(↑κ a) (Set.range f) = 1
a : α
⊢ ↑↑(↑(kernel.comapRight κ hf) a) Set.univ = 1

tactic: simp only [Set.image_univ, Subtype.range_coe_subtype, Set.setOf_mem_eq]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1453265
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
γ : Type u_3
mγ : MeasurableSpace γ
f : γ → β
κ : { x // x ∈ kernel α β }
hf : MeasurableEmbedding f
hκ : ∀ (a : α), ↑↑(↑κ a) (Set.range f) = 1
a : α
⊢ ↑↑(↑κ a) (f '' Set.univ) = 1

tactic: exact hκ a
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1453265
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
γ : Type u_3
mγ : MeasurableSpace γ
f : γ → β
κ : { x // x ∈ kernel α β }
hf : MeasurableEmbedding f
hκ : ∀ (a : α), ↑↑(↑κ a) (Set.range f) = 1
a : α
⊢ ↑↑(↑κ a) (Set.range f) = 1