tasksource/leandojo huggingface dataset:
Theorem: Subspace.dualPairing_eq
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext
state_before: K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
⊢ Submodule.dualPairing W = ↑(quotAnnihilatorEquiv W)

tactic: rfl
state_before: case h.h.h
K : Type u
inst✝⁴ : Field K
V₁ : Type v'
V₂ : Type v''
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
W : Subspace K V₁
x✝¹ : Dual K V₁
x✝ : { x // x ∈ W }
⊢ ↑(↑(LinearMap.comp (Submodule.dualPairing W) (mkQ (dualAnnihilator W))) x✝¹) x✝ =
    ↑(↑(LinearMap.comp (↑(quotAnnihilatorEquiv W)) (mkQ (dualAnnihilator W))) x✝¹) x✝
Theorem: finrank_vectorSpan_image_finset_le
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have hn : (s.image p).Nonempty := by
  rw [Finset.Nonempty.image_iff, ← Finset.card_pos, hc]
  apply Nat.succ_pos
state_before: k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
⊢ finrank k { x // x ∈ vectorSpan k ↑(Finset.image p s) } ≤ n

tactic: rcases hn with ⟨p₁, hp₁⟩
state_before: k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
hn : Finset.Nonempty (Finset.image p s)
⊢ finrank k { x // x ∈ vectorSpan k ↑(Finset.image p s) } ≤ n

tactic: rw [vectorSpan_eq_span_vsub_finset_right_ne k hp₁]
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
p₁ : P
hp₁ : p₁ ∈ Finset.image p s
⊢ finrank k { x // x ∈ vectorSpan k ↑(Finset.image p s) } ≤ n

tactic: refine' le_trans (finrank_span_finset_le_card (((s.image p).erase p₁).image fun p => p -ᵥ p₁)) _
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
p₁ : P
hp₁ : p₁ ∈ Finset.image p s
⊢ finrank k { x // x ∈ Submodule.span k ↑(Finset.image (fun x => x -ᵥ p₁) (Finset.erase (Finset.image p s) p₁)) } ≤ n

tactic: rw [Finset.card_image_of_injective _ (vsub_left_injective p₁), Finset.card_erase_of_mem hp₁,
  tsub_le_iff_right, ← hc]
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
p₁ : P
hp₁ : p₁ ∈ Finset.image p s
⊢ Finset.card (Finset.image (fun p => p -ᵥ p₁) (Finset.erase (Finset.image p s) p₁)) ≤ n

tactic: apply Finset.card_image_le
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
p₁ : P
hp₁ : p₁ ∈ Finset.image p s
⊢ Finset.card (Finset.image p s) ≤ Finset.card s

tactic: rw [Finset.Nonempty.image_iff, ← Finset.card_pos, hc]
state_before: k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
⊢ Finset.Nonempty (Finset.image p s)

tactic: apply Nat.succ_pos
state_before: k : Type u_2
V : Type u_3
P : Type u_4
ι : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : ι → P
s : Finset ι
n : ℕ
hc : Finset.card s = n + 1
⊢ 0 < n + 1
Theorem: Memℓp.const_mul
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: infer_instance
state_before: α : Type u_1
E : α → Type ?u.91570
p q : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_2
inst✝² : NormedRing 𝕜
inst✝¹ : (i : α) → Module 𝕜 (E i)
inst✝ : ∀ (i : α), BoundedSMul 𝕜 (E i)
f : α → 𝕜
hf : Memℓp f p
c : 𝕜
i : α
⊢ BoundedSMul 𝕜 ((fun x => 𝕜) i)
Theorem: TopCat.Presheaf.SheafConditionEqualizerProducts.w
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

tactic: dsimp [res, leftRes, rightRes]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
⊢ res F U ≫ leftRes F U = res F U ≫ rightRes F U

tactic: refine limit.hom_ext (fun _ => ?_)
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
⊢ ((Pi.lift fun i => F.map (leSupr U i).op) ≫
      Pi.lift fun p => Pi.π (fun i => F.obj (U i).op) p.fst ≫ F.map (infLELeft (U p.fst) (U p.snd)).op) =
    (Pi.lift fun i => F.map (leSupr U i).op) ≫
      Pi.lift fun p => Pi.π (fun i => F.obj (U i).op) p.snd ≫ F.map (infLERight (U p.fst) (U p.snd)).op

tactic: simp only [limit.lift_π, limit.lift_π_assoc, Fan.mk_π_app, Category.assoc]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ ((Pi.lift fun i => F.map (leSupr U i).op) ≫
        Pi.lift fun p => Pi.π (fun i => F.obj (U i).op) p.fst ≫ F.map (infLELeft (U p.fst) (U p.snd)).op) ≫
      limit.π (Discrete.functor fun p => F.obj (U p.fst ⊓ U p.snd).op) x✝ =
    ((Pi.lift fun i => F.map (leSupr U i).op) ≫
        Pi.lift fun p => Pi.π (fun i => F.obj (U i).op) p.snd ≫ F.map (infLERight (U p.fst) (U p.snd)).op) ≫
      limit.π (Discrete.functor fun p => F.obj (U p.fst ⊓ U p.snd).op) x✝

tactic: rw [← F.map_comp]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map (leSupr U x✝.as.fst).op ≫ F.map (infLELeft (U x✝.as.fst) (U x✝.as.snd)).op =
    F.map (leSupr U x✝.as.snd).op ≫ F.map (infLERight (U x✝.as.fst) (U x✝.as.snd)).op

tactic: rw [← F.map_comp]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map ((leSupr U x✝.as.fst).op ≫ (infLELeft (U x✝.as.fst) (U x✝.as.snd)).op) =
    F.map (leSupr U x✝.as.snd).op ≫ F.map (infLERight (U x✝.as.fst) (U x✝.as.snd)).op

tactic: congr 1
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map ((leSupr U x✝.as.fst).op ≫ (infLELeft (U x✝.as.fst) (U x✝.as.snd)).op) =
    F.map ((leSupr U x✝.as.snd).op ≫ (infLERight (U x✝.as.fst) (U x✝.as.snd)).op)
Theorem: Std.AssocList.forM_eq
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [*, forM]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_4
inst✝ : Monad m
f : α → β → m PUnit
l : AssocList α β
⊢ forM f l =
    List.forM (toList l) fun x =>
      match x with
      | (a, b) => f a b
Theorem: Primrec.nat_mod
File: Mathlib/Computability/Primrec.lean

tactic: apply Nat.sub_eq_of_eq_add
state_before: α : Type ?u.174271
β : Type ?u.174274
γ : Type ?u.174277
δ : Type ?u.174280
σ : Type ?u.174283
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
m n : ℕ
⊢ (m, n).fst - (m, n).snd * (fun x x_1 => x / x_1) (m, n).fst (m, n).snd = m % n

tactic: simp [add_comm (m % n), Nat.div_add_mod]
state_before: case h
α : Type ?u.174271
β : Type ?u.174274
γ : Type ?u.174277
δ : Type ?u.174280
σ : Type ?u.174283
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
m n : ℕ
⊢ (m, n).fst = m % n + (m, n).snd * (fun x x_1 => x / x_1) (m, n).fst (m, n).snd
Theorem: MvQPF.wrepr_wMk
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: rw [wrepr, recF_eq', q.P.wDest'_wMk]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
⊢ wrepr (MvPFunctor.wMk (P F) a f' f) =
    MvPFunctor.wMk' (P F)
      (repr (abs ((TypeVec.id ::: wrepr) <$$> { fst := a, snd := MvPFunctor.appendContents (P F) f' f })))

tactic: rfl
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
⊢ (MvPFunctor.wMk' (P F) ∘ repr)
      (abs ((TypeVec.id ::: recF (MvPFunctor.wMk' (P F) ∘ repr)) <$$> { fst := a, snd := splitFun f' f })) =
    MvPFunctor.wMk' (P F)
      (repr
        (abs
          ((TypeVec.id ::: recF (MvPFunctor.wMk' (P F) ∘ repr)) <$$>
            { fst := a, snd := MvPFunctor.appendContents (P F) f' f })))
Theorem: TopCat.colimit_isOpen_iff
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: dsimp [topologicalSpace_coe]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
U : Set ↑(colimit F)
⊢ IsOpen U ↔ ∀ (j : J), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)

tactic: conv_lhs => rw [colimit_topology F]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
U : Set ↑(colimit F)
⊢ IsOpen U ↔ ∀ (j : J), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)

tactic: exact isOpen_iSup_iff
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
U : Set ↑(colimit F)
⊢ IsOpen U ↔ ∀ (j : J), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)
Theorem: CategoryTheory.MonoidalCategory.inv_hom_id_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, f.inv_hom_id, id_tensor_comp]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (f.inv ⊗ g) ≫ (f.hom ⊗ h) = (𝟙 W ⊗ g) ≫ (𝟙 W ⊗ h)
Theorem: EMetric.subset_countable_closure_of_compact
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: refine' subset_countable_closure_of_almost_dense_set s fun ε hε => _
state_before: α : Type u
β : Type v
X : Type ?u.280595
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t s : Set α
hs : IsCompact s
⊢ ∃ t, t ⊆ s ∧ Set.Countable t ∧ s ⊆ closure t

tactic: rcases totallyBounded_iff'.1 hs.totallyBounded ε hε with ⟨t, -, htf, hst⟩
state_before: α : Type u
β : Type v
X : Type ?u.280595
inst✝ : PseudoEMetricSpace α
x y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s✝ t s : Set α
hs : IsCompact s
ε : ℝ≥0∞
hε : ε > 0
⊢ ∃ t, Set.Countable t ∧ s ⊆ ⋃ (x : α) (_ : x ∈ t), closedBall x ε

tactic: exact ⟨t, htf.countable, hst.trans <| iUnion₂_mono fun _ _ => ball_subset_closedBall⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
X : Type ?u.280595
inst✝ : PseudoEMetricSpace α
x y z : α
ε✝ ε₁ ε₂ : ℝ≥0∞
s✝ t✝ s : Set α
hs : IsCompact s
ε : ℝ≥0∞
hε : ε > 0
t : Set α
htf : Set.Finite t
hst : s ⊆ ⋃ (y : α) (_ : y ∈ t), ball y ε
⊢ ∃ t, Set.Countable t ∧ s ⊆ ⋃ (x : α) (_ : x ∈ t), closedBall x ε
Theorem: multiplicity.multiplicity_pow_self
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [eq_coe_iff]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ multiplicity p (p ^ n) = ↑n

tactic: use dvd_rfl
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ p ^ n ∣ p ^ n ∧ ¬p ^ (n + 1) ∣ p ^ n

tactic: rw [pow_dvd_pow_iff h0 hu]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ ¬p ^ (n + 1) ∣ p ^ n

tactic: apply Nat.not_succ_le_self
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ ¬n + 1 ≤ n
Theorem: Int.max_eq_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.max_comm b a]
state_before: a b : Int
h : b ≤ a
⊢ max a b = a

tactic: exact Int.max_eq_right h
state_before: a b : Int
h : b ≤ a
⊢ max b a = a
Theorem: Nat.bitwise'_swap
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: funext m n
state_before: f : Bool → Bool → Bool
h : f false false = false
⊢ bitwise' (Function.swap f) = Function.swap (bitwise' f)

tactic: revert n
state_before: case h.h
f : Bool → Bool → Bool
h : f false false = false
m n : ℕ
⊢ bitwise' (Function.swap f) m n = Function.swap (bitwise' f) m n

tactic: dsimp [Function.swap]
state_before: case h.h
f : Bool → Bool → Bool
h : f false false = false
m : ℕ
⊢ ∀ (n : ℕ), bitwise' (Function.swap f) m n = Function.swap (bitwise' f) m n

tactic: apply binaryRec _ _ m <;> intro n
state_before: case h.h
f : Bool → Bool → Bool
h : f false false = false
m : ℕ
⊢ ∀ (n : ℕ), bitwise' (fun y x => f x y) m n = bitwise' f n m

tactic: rw [bitwise'_zero_left, bitwise'_zero_right]
state_before: f : Bool → Bool → Bool
h : f false false = false
m n : ℕ
⊢ bitwise' (fun y x => f x y) 0 n = bitwise' f n 0

tactic: exact h
state_before: case h
f : Bool → Bool → Bool
h : f false false = false
m n : ℕ
⊢ f false false = false

tactic: intros a ih m'
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
n : Bool
⊢ ∀ (n_1 : ℕ),
    (∀ (n : ℕ), bitwise' (fun y x => f x y) n_1 n = bitwise' f n n_1) →
      ∀ (n_2 : ℕ), bitwise' (fun y x => f x y) (bit n n_1) n_2 = bitwise' f n_2 (bit n n_1)

tactic: apply bitCasesOn m'
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
n : Bool
a : ℕ
ih : ∀ (n : ℕ), bitwise' (fun y x => f x y) a n = bitwise' f n a
m' : ℕ
⊢ bitwise' (fun y x => f x y) (bit n a) m' = bitwise' f m' (bit n a)

tactic: intro b n'
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
n : Bool
a : ℕ
ih : ∀ (n : ℕ), bitwise' (fun y x => f x y) a n = bitwise' f n a
m' : ℕ
⊢ ∀ (b : Bool) (n_1 : ℕ), bitwise' (fun y x => f x y) (bit n a) (bit b n_1) = bitwise' f (bit b n_1) (bit n a)

tactic: rw [bitwise'_bit, bitwise'_bit, ih] <;> exact h
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
n : Bool
a : ℕ
ih : ∀ (n : ℕ), bitwise' (fun y x => f x y) a n = bitwise' f n a
m' : ℕ
b : Bool
n' : ℕ
⊢ bitwise' (fun y x => f x y) (bit n a) (bit b n') = bitwise' f (bit b n') (bit n a)
Theorem: Matrix.right_inv_eq_left_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← inv_eq_right_inv h, ← inv_eq_left_inv g]
state_before: l : Type ?u.261753
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B C : Matrix n n α
h : A ⬝ B = 1
g : C ⬝ A = 1
⊢ B = C
Theorem: Ordinal.one_le_iff_pos
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← succ_zero, succ_le_iff]
state_before: α : Type ?u.179673
β : Type ?u.179676
γ : Type ?u.179679
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ 1 ≤ o ↔ 0 < o
Theorem: Nat.cast_pos
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: cases n <;> simp [cast_add_one_pos]
state_before: α : Type u_1
β : Type ?u.13001
inst✝¹ : OrderedSemiring α
inst✝ : Nontrivial α
n : ℕ
⊢ 0 < ↑n ↔ 0 < n
Theorem: EqualCharZero.to_not_mixedCharZero
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: intro p p_pos
state_before: R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p

tactic: by_contra hp_mixedChar
state_before: R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
p : ℕ
p_pos : p > 0
⊢ ¬MixedCharZero R p

tactic: rcases hp_mixedChar.charP_quotient with ⟨I, hI_ne_top, hI_p⟩
state_before: R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
p : ℕ
p_pos : p > 0
hp_mixedChar : MixedCharZero R p
⊢ False

tactic: replace hI_zero : CharP (R ⧸ I) 0 := @CharP.ofCharZero _ _ (h I hI_ne_top)
state_before: case intro.intro
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
p : ℕ
p_pos : p > 0
hp_mixedChar : MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
hI_p : CharP (R ⧸ I) p
⊢ False

tactic: exact absurd (CharP.eq (R ⧸ I) hI_p hI_zero) (ne_of_gt p_pos)
state_before: case intro.intro
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
p : ℕ
p_pos : p > 0
hp_mixedChar : MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
hI_p : CharP (R ⧸ I) p
hI_zero : CharP (R ⧸ I) 0
⊢ False
Theorem: Complex.cos_conj
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cosh_mul_I, ← conj_neg_I, ← RingHom.map_mul, ← cosh_mul_I, cosh_conj, mul_neg, cosh_neg]
state_before: x y : ℂ
⊢ cos (↑(starRingEnd ℂ) x) = ↑(starRingEnd ℂ) (cos x)
Theorem: Nat.coprime_mul_left_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [coprime, coprime, gcd_mul_left_add_left]
state_before: m n k : ℕ
⊢ coprime (n * k + m) n ↔ coprime m n
Theorem: Polynomial.support_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: ext i
state_before: R : Type u
S : Type ?u.69179
inst✝ : Ring R
p : R[X]
⊢ support (restriction p) = support p

tactic: simp only [mem_support_iff, not_iff_not, Ne.def]
state_before: case a
R : Type u
S : Type ?u.69179
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ i ∈ support (restriction p) ↔ i ∈ support p

tactic: conv_rhs => rw [← coeff_restriction]
state_before: case a
R : Type u
S : Type ?u.69179
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ coeff (restriction p) i = 0 ↔ coeff p i = 0

tactic: exact ⟨fun H => by rw [H, ZeroMemClass.coe_zero], fun H => Subtype.coe_injective H⟩
state_before: case a
R : Type u
S : Type ?u.69179
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ coeff (restriction p) i = 0 ↔ ↑(coeff (restriction p) i) = 0

tactic: rw [H, ZeroMemClass.coe_zero]
state_before: R : Type u
S : Type ?u.69179
inst✝ : Ring R
p : R[X]
i : ℕ
H : coeff (restriction p) i = 0
⊢ ↑(coeff (restriction p) i) = 0
Theorem: Real.logb_lt_logb_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_lt_div_right_of_neg (log_neg b_pos b_lt_one)]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hxy : x < y
⊢ logb b y < logb b x

tactic: exact log_lt_log hx hxy
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hxy : x < y
⊢ log x < log y
Theorem: Composition.sizeUpTo_zero
File: Mathlib/Combinatorics/Composition.lean

tactic: simp [sizeUpTo]
state_before: n : ℕ
c : Composition n
⊢ sizeUpTo c 0 = 0
Theorem: Trivialization.coordChange_coordChange
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [coordChange, e₁.mk_coordChange _ h₁ h₂, ← e₂.coe_coe, e₂.left_inv, coordChange]
state_before: ι : Type ?u.55888
B : Type u_1
F : Type u_2
E : B → Type ?u.55899
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e₁ e₂ e₃ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ coordChange e₂ e₃ b (coordChange e₁ e₂ b x) = coordChange e₁ e₃ b x

tactic: rwa [e₂.mem_source, e₁.proj_symm_apply' h₁]
state_before: ι : Type ?u.55888
B : Type u_1
F : Type u_2
E : B → Type ?u.55899
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e₁ e₂ e₃ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ ↑(LocalHomeomorph.symm e₁.toLocalHomeomorph) (b, x) ∈ e₂.source
Theorem: MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_sum_measure
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: contrapose! H
state_before: α : Type u_1
β : Type ?u.42415
γ : Type ?u.42418
δ : Type ?u.42421
ι : Type u_2
R : Type ?u.42427
R' : Type ?u.42430
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ (i : ι), i ∈ s → MeasurableSet (t i)
H : ↑↑μ univ < ∑ i in s, ↑↑μ (t i)
⊢ ∃ i, i ∈ s ∧ ∃ j, j ∈ s ∧ ∃ _h, Set.Nonempty (t i ∩ t j)

tactic: apply sum_measure_le_measure_univ h
state_before: α : Type u_1
β : Type ?u.42415
γ : Type ?u.42418
δ : Type ?u.42421
ι : Type u_2
R : Type ?u.42427
R' : Type ?u.42430
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ (i : ι), i ∈ s → MeasurableSet (t i)
H : ∀ (i : ι), i ∈ s → ∀ (j : ι), j ∈ s → i ≠ j → ¬Set.Nonempty (t i ∩ t j)
⊢ ∑ i in s, ↑↑μ (t i) ≤ ↑↑μ univ

tactic: intro i hi j hj hij
state_before: α : Type u_1
β : Type ?u.42415
γ : Type ?u.42418
δ : Type ?u.42421
ι : Type u_2
R : Type ?u.42427
R' : Type ?u.42430
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ (i : ι), i ∈ s → MeasurableSet (t i)
H : ∀ (i : ι), i ∈ s → ∀ (j : ι), j ∈ s → i ≠ j → ¬Set.Nonempty (t i ∩ t j)
⊢ PairwiseDisjoint ↑s fun i => t i

tactic: rw [Function.onFun, disjoint_iff_inf_le]
state_before: α : Type u_1
β : Type ?u.42415
γ : Type ?u.42418
δ : Type ?u.42421
ι : Type u_2
R : Type ?u.42427
R' : Type ?u.42430
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ (i : ι), i ∈ s → MeasurableSet (t i)
H : ∀ (i : ι), i ∈ s → ∀ (j : ι), j ∈ s → i ≠ j → ¬Set.Nonempty (t i ∩ t j)
i : ι
hi : i ∈ ↑s
j : ι
hj : j ∈ ↑s
hij : i ≠ j
⊢ (Disjoint on fun i => t i) i j

tactic: exact fun x hx => H i hi j hj hij ⟨x, hx⟩
state_before: α : Type u_1
β : Type ?u.42415
γ : Type ?u.42418
δ : Type ?u.42421
ι : Type u_2
R : Type ?u.42427
R' : Type ?u.42430
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
m : MeasurableSpace α
μ : Measure α
s : Finset ι
t : ι → Set α
h : ∀ (i : ι), i ∈ s → MeasurableSet (t i)
H : ∀ (i : ι), i ∈ s → ∀ (j : ι), j ∈ s → i ≠ j → ¬Set.Nonempty (t i ∩ t j)
i : ι
hi : i ∈ ↑s
j : ι
hj : j ∈ ↑s
hij : i ≠ j
⊢ t i ⊓ t j ≤ ⊥
Theorem: MeasureTheory.Integrable.norm_toL1
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [toL1, snorm, snorm']
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1315289
δ : Type ?u.1315292
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f
⊢ ‖toL1 f hf‖ = ENNReal.toReal (∫⁻ (a : α), edist (f a) 0 ∂μ)

tactic: simp [edist_eq_coe_nnnorm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1315289
δ : Type ?u.1315292
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f
⊢ ENNReal.toReal (∫⁻ (a : α), ↑‖f a‖₊ ∂μ) = ENNReal.toReal (∫⁻ (a : α), edist (f a) 0 ∂μ)
Theorem: Finset.Ioc_union_Ioc_eq_Ioc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_union, coe_Ioc, coe_Ioc, coe_Ioc, Set.Ioc_union_Ioc_eq_Ioc h₁ h₂]
state_before: ι : Type ?u.125811
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h₁ : a ≤ b
h₂ : b ≤ c
⊢ Ioc a b ∪ Ioc b c = Ioc a c