tasksource/leandojo huggingface dataset:
Theorem: Polynomial.isUnit_iff_degree_eq_zero
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp [*, le_refl]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 0
⊢ degree p ≤ 0

tactic: rw [eq_C_of_degree_le_zero this, hc] at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 0
this : degree p ≤ 0
hc : coeff p 0 = 0
⊢ False

tactic: simp at h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree (↑C 0) = 0
this : degree p ≤ 0
hc : coeff p 0 = 0
⊢ False

tactic: conv in p => rw [eq_C_of_degree_le_zero this]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 0
this : degree p ≤ 0
hc : coeff p 0 ≠ 0
⊢ 1 = p * ↑C (coeff p 0)⁻¹

tactic: rw [← C_mul, _root_.mul_inv_cancel hc, C_1]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
h : degree p = 0
this : degree p ≤ 0
hc : coeff p 0 ≠ 0
⊢ 1 = ↑C (coeff p 0) * ↑C (coeff p 0)⁻¹
Theorem: RatFunc.intDegree_polynomial
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [intDegree, RatFunc.num_algebraMap, RatFunc.denom_algebraMap, Polynomial.natDegree_one,
  Int.ofNat_zero, sub_zero]
state_before: K : Type u
inst✝ : Field K
p : K[X]
⊢ intDegree (↑(algebraMap K[X] (RatFunc K)) p) = ↑(natDegree p)
Theorem: UniformInducing.inducing
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: obtain rfl := h.comap_uniformSpace
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformInducing f
⊢ Inducing f

tactic: exact inducing_induced f
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformInducing f
⊢ Inducing f
Theorem: rotation_ne_conjLie
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: intro h
state_before: a : { x // x ∈ circle }
⊢ ↑rotation a ≠ conjLie

tactic: have h1 : rotation a 1 = conj 1 := LinearIsometryEquiv.congr_fun h 1
state_before: a : { x // x ∈ circle }
h : ↑rotation a = conjLie
⊢ False

tactic: have hI : rotation a I = conj I := LinearIsometryEquiv.congr_fun h I
state_before: a : { x // x ∈ circle }
h : ↑rotation a = conjLie
h1 : ↑(↑rotation a) 1 = ↑(starRingEnd ℂ) 1
⊢ False

tactic: rw [rotation_apply, RingHom.map_one, mul_one] at h1
state_before: a : { x // x ∈ circle }
h : ↑rotation a = conjLie
h1 : ↑(↑rotation a) 1 = ↑(starRingEnd ℂ) 1
hI : ↑(↑rotation a) I = ↑(starRingEnd ℂ) I
⊢ False

tactic: rw [rotation_apply, conj_I, ← neg_one_mul, mul_left_inj' I_ne_zero, h1, eq_neg_self_iff] at hI
state_before: a : { x // x ∈ circle }
h : ↑rotation a = conjLie
h1 : ↑a = 1
hI : ↑(↑rotation a) I = ↑(starRingEnd ℂ) I
⊢ False

tactic: exact one_ne_zero hI
state_before: a : { x // x ∈ circle }
h : ↑rotation a = conjLie
h1 : ↑a = 1
hI : 1 = 0
⊢ False
Theorem: hammingDist_eq_hammingNorm
File: Mathlib/InformationTheory/Hamming.lean

tactic: simp_rw [hammingNorm, hammingDist, Pi.sub_apply, sub_ne_zero]
state_before: α : Type ?u.32980
ι : Type u_2
β : ι → Type u_1
inst✝³ : Fintype ι
inst✝² : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.33012
inst✝¹ : (i : ι) → DecidableEq (γ i)
inst✝ : (i : ι) → AddGroup (β i)
x y : (i : ι) → β i
⊢ hammingDist x y = hammingNorm (x - y)
Theorem: RightOrdContinuous.id
File: Mathlib/Order/OrdContinuous.lean

tactic: simpa only [image_id] using h
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
s : Set α
x : α
h : IsGLB s x
⊢ IsGLB (id '' s) (id x)
Theorem: Stream'.Seq.map_comp
File: Mathlib/Data/Seq/Seq.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : IsSeq s
⊢ map (g ∘ f) { val := s, property := al } = map g (map f { val := s, property := al })

tactic: dsimp [map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : IsSeq s
⊢ ↑(map (g ∘ f) { val := s, property := al }) = ↑(map g (map f { val := s, property := al }))

tactic: apply congr_arg fun f : _ → Option γ => Stream'.map f s
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : IsSeq s
⊢ Stream'.map (Option.map (g ∘ f)) s = Stream'.map (Option.map g ∘ Option.map f) s

tactic: ext ⟨⟩ <;> rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : IsSeq s
⊢ Option.map (g ∘ f) = Option.map g ∘ Option.map f
Theorem: Mathlib.Tactic.Ring.inv_single
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [*]
state_before: u : Lean.Level
R✝ : Type ?u.356885
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a b : R
x✝ : a⁻¹ = b
⊢ (a + 0)⁻¹ = b + 0
Theorem: BoxIntegral.Prepartition.ofWithBot_le
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: have : ∀ J : Box ι, ↑J ∈ boxes → ∃ J' ∈ π, J ≤ J' := fun J hJ => by
  simpa only [WithBot.coe_le_coe] using H J hJ WithBot.coe_ne_bot
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≠ ⊥ → ∃ J', J' ∈ π ∧ J ≤ ↑J'
⊢ ofWithBot boxes le_of_mem pairwise_disjoint ≤ π

tactic: simpa [ofWithBot, le_def]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≠ ⊥ → ∃ J', J' ∈ π ∧ J ≤ ↑J'
this : ∀ (J : Box ι), ↑J ∈ boxes → ∃ J', J' ∈ π ∧ J ≤ J'
⊢ ofWithBot boxes le_of_mem pairwise_disjoint ≤ π

tactic: simpa only [WithBot.coe_le_coe] using H J hJ WithBot.coe_ne_bot
state_before: ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≠ ⊥ → ∃ J', J' ∈ π ∧ J ≤ ↑J'
J : Box ι
hJ : ↑J ∈ boxes
⊢ ∃ J', J' ∈ π ∧ J ≤ J'
Theorem: Set.Icc_prod_Icc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a₁ a₂ : α
b₁ b₂ : β
⊢ Icc a₁ a₂ ×ˢ Icc b₁ b₂ = Icc (a₁, b₁) (a₂, b₂)

tactic: simp [and_assoc, and_comm, and_left_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a₁ a₂ : α
b₁ b₂ : β
x : α
y : β
⊢ (x, y) ∈ Icc a₁ a₂ ×ˢ Icc b₁ b₂ ↔ (x, y) ∈ Icc (a₁, b₁) (a₂, b₂)
Theorem: CauSeq.Completion.ofRat_inv
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: split_ifs with h <;> [simp [const_limZero.1 h]; rfl]
state_before: α : Type u_2
inst✝² : LinearOrderedField α
β : Type u_1
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : β
⊢ const abv x⁻¹ = if h : LimZero (const abv x) then 0 else inv (const abv x) h
Theorem: FirstOrder.Language.LHom.setOf_realize_onFormula
File: Mathlib/ModelTheory/Semantics.lean

tactic: ext
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.247641
P : Type ?u.247644
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
ψ : Formula L α
⊢ setOf (Formula.Realize (onFormula φ ψ)) = setOf (Formula.Realize ψ)

tactic: simp
state_before: case h
L : Language
L' : Language
M : Type w
N : Type ?u.247641
P : Type ?u.247644
inst✝⁴ : Structure L M
inst✝³ : Structure L N
inst✝² : Structure L P
α : Type u'
β : Type v'
n : ℕ
inst✝¹ : Structure L' M
φ : L →ᴸ L'
inst✝ : IsExpansionOn φ M
ψ : Formula L α
x✝ : α → M
⊢ x✝ ∈ setOf (Formula.Realize (onFormula φ ψ)) ↔ x✝ ∈ setOf (Formula.Realize ψ)
Theorem: Polynomial.degree_map_eq_of_injective
File: Mathlib/Data/Polynomial/Monic.lean

tactic: simp [h]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ↑f
p : R[X]
h : p = 0
⊢ degree (map f p) = degree p

tactic: rw [← f.map_zero]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ↑f
p : R[X]
h : ¬p = 0
⊢ ↑f (leadingCoeff p) ≠ 0

tactic: exact mt hf.eq_iff.1 (mt leadingCoeff_eq_zero.1 h)
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ↑f
p : R[X]
h : ¬p = 0
⊢ ↑f (leadingCoeff p) ≠ ↑f 0
Theorem: HahnSeries.SummableFamily.coe_injective
File: Mathlib/RingTheory/HahnSeries.lean

tactic: congr
state_before: Γ : Type u_3
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_1
f1 : α → HahnSeries Γ R
hU1 : Set.IsPwo (⋃ (a : α), support (f1 a))
hf1 : ∀ (g : Γ), Set.Finite {a | coeff (f1 a) g ≠ 0}
f2 : α → HahnSeries Γ R
isPwo_iUnion_support'✝ : Set.IsPwo (⋃ (a : α), support (f2 a))
finite_co_support'✝ : ∀ (g : Γ), Set.Finite {a | coeff (f2 a) g ≠ 0}
h :
  { toFun := f1, isPwo_iUnion_support' := hU1, finite_co_support' := hf1 }.toFun =
    { toFun := f2, isPwo_iUnion_support' := isPwo_iUnion_support'✝, finite_co_support' := finite_co_support'✝ }.toFun
⊢ { toFun := f1, isPwo_iUnion_support' := hU1, finite_co_support' := hf1 } =
    { toFun := f2, isPwo_iUnion_support' := isPwo_iUnion_support'✝, finite_co_support' := finite_co_support'✝ }
Theorem: WithTop.le_of_add_le_add_right
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: lift a to α using ha
state_before: α : Type u
β : Type v
inst✝² : Add α
a b c d : WithTop α
x y : α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
ha : a ≠ ⊤
h : b + a ≤ c + a
⊢ b ≤ c

tactic: cases c
state_before: case intro
α : Type u
β : Type v
inst✝² : Add α
b c d : WithTop α
x y : α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a : α
h : b + ↑a ≤ c + ↑a
⊢ b ≤ c

tactic: exact le_top
state_before: case intro.none
α : Type u
β : Type v
inst✝² : Add α
b d : WithTop α
x y : α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a : α
h : b + ↑a ≤ none + ↑a
⊢ b ≤ none

tactic: cases b
state_before: case intro.some
α : Type u
β : Type v
inst✝² : Add α
b d : WithTop α
x y : α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a val✝ : α
h : b + ↑a ≤ Option.some val✝ + ↑a
⊢ b ≤ Option.some val✝

tactic: exact (not_top_le_coe _ h).elim
state_before: case intro.some.none
α : Type u
β : Type v
inst✝² : Add α
d : WithTop α
x y : α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a val✝ : α
h : none + ↑a ≤ Option.some val✝ + ↑a
⊢ none ≤ Option.some val✝

tactic: exact coe_le_coe.2 (le_of_add_le_add_right <| coe_le_coe.1 h)
state_before: case intro.some.some
α : Type u
β : Type v
inst✝² : Add α
d : WithTop α
x y : α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a val✝¹ val✝ : α
h : Option.some val✝ + ↑a ≤ Option.some val✝¹ + ↑a
⊢ Option.some val✝ ≤ Option.some val✝¹
Theorem: covby_iff_quot_is_simple
File: Mathlib/RingTheory/SimpleModule.lean

tactic: set f : Submodule R B ≃o Set.Iic B := Submodule.MapSubtype.relIso B with hf
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.20136
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
⊢ A ⋖ B ↔ IsSimpleModule R ({ x // x ∈ B } ⧸ Submodule.comap (Submodule.subtype B) A)

tactic: rw [covby_iff_coatom_Iic hAB, isSimpleModule_iff_isCoatom, ← OrderIso.isCoatom_iff f, hf]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.20136
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
f : Submodule R { x // x ∈ B } ≃o ↑(Set.Iic B) := Submodule.MapSubtype.relIso B
hf : f = Submodule.MapSubtype.relIso B
⊢ A ⋖ B ↔ IsSimpleModule R ({ x // x ∈ B } ⧸ Submodule.comap (Submodule.subtype B) A)

tactic: simp [-OrderIso.isCoatom_iff, Submodule.MapSubtype.relIso, Submodule.map_comap_subtype,
  inf_eq_right.2 hAB]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.20136
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
f : Submodule R { x // x ∈ B } ≃o ↑(Set.Iic B) := Submodule.MapSubtype.relIso B
hf : f = Submodule.MapSubtype.relIso B
⊢ IsCoatom { val := A, property := hAB } ↔
    IsCoatom (↑(Submodule.MapSubtype.relIso B) (Submodule.comap (Submodule.subtype B) A))
Theorem: Subsemiring.prod_top
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_fst]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Subsemiring R
x : R × S
⊢ x ∈ prod s ⊤ ↔ x ∈ comap (RingHom.fst R S) s
Theorem: AdjoinRoot.Minpoly.toAdjoin.surjective
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [← range_top_iff_surjective, _root_.eq_top_iff, ← adjoin_adjoin_coe_preimage]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
⊢ Function.Surjective ↑(toAdjoin R x)

tactic: refine' adjoin_le _
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
⊢ adjoin R (Subtype.val ⁻¹' {x}) ≤ AlgHom.range (toAdjoin R x)

tactic: simp only [AlgHom.coe_range, Set.mem_range]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
⊢ Subtype.val ⁻¹' {x} ⊆ ↑(AlgHom.range (toAdjoin R x))

tactic: rintro ⟨y₁, y₂⟩ h
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
⊢ Subtype.val ⁻¹' {x} ⊆ Set.range ↑(toAdjoin R x)

tactic: refine' ⟨mk (minpoly R x) X, by simpa [toAdjoin] using h.symm⟩
state_before: case mk
R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x y₁ : S
y₂ : y₁ ∈ ↑(adjoin R {x})
h : { val := y₁, property := y₂ } ∈ Subtype.val ⁻¹' {x}
⊢ { val := y₁, property := y₂ } ∈ Set.range ↑(toAdjoin R x)

tactic: simpa [toAdjoin] using h.symm
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x y₁ : S
y₂ : y₁ ∈ ↑(adjoin R {x})
h : { val := y₁, property := y₂ } ∈ Subtype.val ⁻¹' {x}
⊢ ↑(toAdjoin R x) (↑(mk (minpoly R x)) X) = { val := y₁, property := y₂ }
Theorem: Int.preimage_Iic
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.247856
α : Type u_1
β : Type ?u.247862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ Int.cast ⁻¹' Iic a = Iic ⌊a⌋

tactic: simp [le_floor]
state_before: case h
F : Type ?u.247856
α : Type u_1
β : Type ?u.247862
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Iic a ↔ x✝ ∈ Iic ⌊a⌋
Theorem: Mathlib.Meta.NormNum.isInt_eq_false
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
n✝¹ n✝ : ℤ
h : decide (n✝¹ = n✝) = false
⊢ ¬↑n✝¹ = ↑n✝

tactic: exact of_decide_eq_false h
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
n✝¹ n✝ : ℤ
h : decide (n✝¹ = n✝) = false
⊢ ¬n✝¹ = n✝
Theorem: CategoryTheory.MorphismProperty.StableUnderBaseChange.baseChange_map
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: let e :=
  pullbackRightPullbackFstIso Y.hom f g.left ≪≫
    pullback.congrHom (g.w.trans (Category.comp_id _)) rfl
state_before: C : Type u
inst✝² : Category C
D : Type ?u.24086
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
S S' : C
f : S' ⟶ S
X Y : Over S
g : X ⟶ Y
H : P g.left
⊢ P ((baseChange f).map g).left

tactic: have : e.inv ≫ pullback.snd = ((baseChange f).map g).left := by
  apply pullback.hom_ext <;> dsimp <;> simp
state_before: C : Type u
inst✝² : Category C
D : Type ?u.24086
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
S S' : C
f : S' ⟶ S
X Y : Over S
g : X ⟶ Y
H : P g.left
e : pullback g.left pullback.fst ≅ pullback X.hom f :=
  pullbackRightPullbackFstIso Y.hom f g.left ≪≫ pullback.congrHom (_ : (𝟭 C).map g.left ≫ Y.hom = X.hom) (_ : f = f)
⊢ P ((baseChange f).map g).left

tactic: rw [← this, hP.respectsIso.cancel_left_isIso]
state_before: C : Type u
inst✝² : Category C
D : Type ?u.24086
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
S S' : C
f : S' ⟶ S
X Y : Over S
g : X ⟶ Y
H : P g.left
e : pullback g.left pullback.fst ≅ pullback X.hom f :=
  pullbackRightPullbackFstIso Y.hom f g.left ≪≫ pullback.congrHom (_ : (𝟭 C).map g.left ≫ Y.hom = X.hom) (_ : f = f)
this : e.inv ≫ pullback.snd = ((baseChange f).map g).left
⊢ P ((baseChange f).map g).left

tactic: exact hP.snd _ _ H
state_before: C : Type u
inst✝² : Category C
D : Type ?u.24086
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
S S' : C
f : S' ⟶ S
X Y : Over S
g : X ⟶ Y
H : P g.left
e : pullback g.left pullback.fst ≅ pullback X.hom f :=
  pullbackRightPullbackFstIso Y.hom f g.left ≪≫ pullback.congrHom (_ : (𝟭 C).map g.left ≫ Y.hom = X.hom) (_ : f = f)
this : e.inv ≫ pullback.snd = ((baseChange f).map g).left
⊢ P pullback.snd

tactic: apply pullback.hom_ext <;> dsimp <;> simp
state_before: C : Type u
inst✝² : Category C
D : Type ?u.24086
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
S S' : C
f : S' ⟶ S
X Y : Over S
g : X ⟶ Y
H : P g.left
e : pullback g.left pullback.fst ≅ pullback X.hom f :=
  pullbackRightPullbackFstIso Y.hom f g.left ≪≫ pullback.congrHom (_ : (𝟭 C).map g.left ≫ Y.hom = X.hom) (_ : f = f)
⊢ e.inv ≫ pullback.snd = ((baseChange f).map g).left
Theorem: Real.log_pow
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: induction' n with n ih
state_before: x✝ y x : ℝ
n : ℕ
⊢ log (x ^ n) = ↑n * log x

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: case succ
x✝ y x : ℝ
n : ℕ
ih : log (x ^ n) = ↑n * log x
⊢ log (x ^ Nat.succ n) = ↑(Nat.succ n) * log x

tactic: rw [pow_succ', log_mul (pow_ne_zero _ hx) hx, ih, Nat.cast_succ, add_mul, one_mul]
state_before: case succ.inr
x✝ y x : ℝ
n : ℕ
ih : log (x ^ n) = ↑n * log x
hx : x ≠ 0
⊢ log (x ^ Nat.succ n) = ↑(Nat.succ n) * log x

tactic: simp
state_before: case zero
x✝ y x : ℝ
⊢ log (x ^ Nat.zero) = ↑Nat.zero * log x

tactic: simp
state_before: case succ.inl
x y : ℝ
n : ℕ
ih : log (0 ^ n) = ↑n * log 0
⊢ log (0 ^ Nat.succ n) = ↑(Nat.succ n) * log 0
Theorem: card_le_of_injective'
File: Mathlib/LinearAlgebra/InvariantBasisNumber.lean

tactic: let P := Finsupp.linearEquivFunOnFinite R R β
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Injective ↑f
⊢ Fintype.card α ≤ Fintype.card β

tactic: let Q := (Finsupp.linearEquivFunOnFinite R R α).symm
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Injective ↑f
P : (β →₀ R) ≃ₗ[R] β → R := Finsupp.linearEquivFunOnFinite R R β
⊢ Fintype.card α ≤ Fintype.card β

tactic: exact
  card_le_of_injective R ((P.toLinearMap.comp f).comp Q.toLinearMap)
    ((P.injective.comp i).comp Q.injective)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α →₀ R) →ₗ[R] β →₀ R
i : Injective ↑f
P : (β →₀ R) ≃ₗ[R] β → R := Finsupp.linearEquivFunOnFinite R R β
Q : (α → R) ≃ₗ[R] α →₀ R := LinearEquiv.symm (Finsupp.linearEquivFunOnFinite R R α)
⊢ Fintype.card α ≤ Fintype.card β
Theorem: LeftOrdContinuous.map_sup
File: Mathlib/Order/OrdContinuous.lean

tactic: simp only [image_pair, isLUB_pair]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
hf : LeftOrdContinuous f
x y : α
⊢ IsLUB (f '' {x, y}) (f x ⊔ f y)
Theorem: PGame.sub_zero
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [neg_zero]
state_before: x : PGame
⊢ x + -0 = x + 0
Theorem: PosNum.to_int_eq_succ_pred
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← n.to_nat_to_int, to_nat_eq_succ_pred]
state_before: α : Type ?u.845967
n : PosNum
⊢ ↑n = ↑↑(pred' n) + 1

tactic: rfl
state_before: α : Type ?u.845967
n : PosNum
⊢ ↑(↑(pred' n) + 1) = ↑↑(pred' n) + 1
Theorem: MeasurableSpace.measurableSet_sSup
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: change GenerateMeasurable (⋃₀ _) _ ↔ _
state_before: α : Type u_1
β : Type ?u.31417
γ : Type ?u.31420
δ : Type ?u.31423
δ' : Type ?u.31426
ι : Sort ?u.31429
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ MeasurableSet s ↔ GenerateMeasurable {s | ∃ m, m ∈ ms ∧ MeasurableSet s} s

tactic: simp [← setOf_exists]
state_before: α : Type u_1
β : Type ?u.31417
γ : Type ?u.31420
δ : Type ?u.31423
δ' : Type ?u.31426
ι : Sort ?u.31429
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ GenerateMeasurable (⋃₀ ((fun m => {t | MeasurableSet t}) '' ms)) s ↔
    GenerateMeasurable {s | ∃ m, m ∈ ms ∧ MeasurableSet s} s
Theorem: Localization.algEquiv_mk
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [mk_eq_mk', algEquiv_mk']
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2935542
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
⊢ ↑(algEquiv M S) (mk x y) = mk' S x y
Theorem: Nat.eq_mul_of_div_eq_left
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [mul_comm, Nat.eq_mul_of_div_eq_right H1 H2]
state_before: m n k a b c : ℕ
H1 : b ∣ a
H2 : a / b = c
⊢ a = c * b
Theorem: CategoryTheory.ProjectiveResolution.π_f_succ
File: Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean

tactic: apply zero_of_target_iso_zero
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroObject C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasEqualizers C
inst✝ : HasImages C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ HomologicalComplex.Hom.f P.π (n + 1) = 0

tactic: dsimp
state_before: case i
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroObject C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasEqualizers C
inst✝ : HasImages C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ HomologicalComplex.X ((ChainComplex.single₀ C).obj Z) (n + 1) ≅ 0

tactic: rfl
state_before: case i
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroObject C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasEqualizers C
inst✝ : HasImages C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ 0 ≅ 0
Theorem: WittVector.wittNeg_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type ?u.70738
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittNeg p 0 = -X (0, 0)

tactic: simp only [wittNeg, wittStructureRat, rename_X, xInTermsOfW_zero, map_X, wittPolynomial_zero,
  RingHom.map_neg, AlgHom.map_neg, bind₁_X_right, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type ?u.70738
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ ↑(map (Int.castRingHom ℚ)) (wittNeg p 0) = ↑(map (Int.castRingHom ℚ)) (-X (0, 0))